BPEL and Aspect Oriented Programming ?

Is there any way to have croscutting concerns (e.g. logging, security, compensation, etc.) in BPEL processes ?
I have to write several BPEL processes with common functionality and I would like to know if this can be achieved reusing functionality, or I have to copy-and-paste common functionality in all my processes.
If I change some functionality, do I have to change all my processes ?
Any suggestion or recommendation is welcome.

You could try having some seperate BPEL processes to address some of the aspects. This will be easier with some aspects than others.
If you always invoke the default version of the aspect processes then as you modify the aspects then it will be possible to modify behaviour by redploying the aspect process and promoting it to be the default.

Similar Messages

Aspect-Orientated Programming?

I have been looking through a few documents to try give me a better understanding of Aspect-Orientated Programming.
I was wondering if it is possible to write a class using AspectJ which could tell me details about a running Java program such as what methods are called and when.
Basically I am wondering whether it's possible to write a class using aspectJ which can capture information from another running class?
I am not looking to find out how this is done, just whether it is possible.
Thanks.

Yes, you would just create a pointcut that
encompasses all methods in A, then write whatyou
want done for that join point in your aspectI assume though that I would have to add thesepoint
cuts to the source code of class A myself? Thersis
no way to get these point cuts into class Awithout
writing into the source?Just to reiterate - things like pointcuts are part of
the aspect, not the source - (one of ) the point of
AOP is to not have to touch the source, all the logic
is contained within the aspect and injected into
the class file, not the source file.Right. You can think of servlet filters as being similar to aspects. You write the filter, but you only run it when you put it into your web.xml. It can be called before the servlet to operate on the request or, in the latest version of the servlet spec, after the servlet to operate on the response.
Your point exactly, Lee. It's not part of the source code for the class being operated on. It's a separate class, configured in a deployment descriptor.
%

Article: Object-flow Programming - Merging Dataflow and Object-Oriented Programming

I just posted an ExpressionFlow article:
Object-flow Programming - Merging Dataflow and Object-Oriented Programming
I guess you may find it interesting. If you like it, you should
bookmark it with one of the social bookmarking tools (click the
bookmark link next to the timeline image in the article). That may help
us to get readers and comments from outside the LabVIEW community. And
don't hesitate to participate the discussion. I'd love to hear you
comments on the subject.
Tomi
Tomi Maila

After having problems with spam block software malfunction, I was able recover the following comments to the EXPRESSIONFLOW article Object-flow Programming - Merging Dataflow and Object-Oriented Programming
Written by Zen:
Some combination of data-flow and object-oriented programming, I think,
could make a great impact on sysytem development. However, I see it in
slightly different way than yours....
Written by Matt Holt:
I don't believe NI can get object-flow programming to move far enough
into mainstream that Forbes would cover it. NI has a bit of a
stranglehold on LabVIEW with it's price as compared to say… VS2005. It
seems that by promoting it as "easy to use" that NI may have shot
itself in the foot….
Written by Jim Kring:
Hi Tomi, In my opinion, LabVIEW's native object-oriented programming
capabilities (LabVOOP) do not currently provide a complete tool for
allowing us to implement our OOP system designs. Nearly all of my
system designs require distributed active objects by reference. I think
that National Instruments certainly can evolve LabVIEW to address such
requirements, but I think that it is not a real focus of NI....
If anybody else is missing their comments, I'm sorry I was unable to recover them. Please repost your comments, I appology for the inconvenience.
Tomi Maila

UML diagrams and Object Oriented programming

In a project for CSC120 at school we have to program a casino using java. We were given a UML diagram of how the professor wants it set up, and I am having some difficulty understanding exactly what some of this means, code wise.
Part of the UML diagram:
Game
userMoney: int
bet: int
playAgain() : bool
askBet() : int
Payout(amt: void) : void
takeBet(amt:void) : bool
I understand the first two blocks, but the last one confuses me. I get that these are the different functions the class will use, but what does the text inside the parentheses mean, and the text after the colon? And what would this look like in code? If someone could post a link to an example program it would greatly help, or just post a simple example here.
Here is what I have so far in the class file:
* ASCIIcasino.java
* Version 1.0
* Alachine
* Last Modified: 01/19/2006
public class Game
     int usermoney;
     int bet;
    public boolean playAgain()
    public int askBet ()
         do
               System.out.println("How much do you wish to bet?");
               scannergameinput = new Scanner(System.in);
          while(!scannergameinput.hasNextInt());
          bet = scannergameinput.nextInt();
          System.out.print("Your bet: ");
         return bet;
    public void Payout ()
         int amt;
    public boolean takeBet ()
         int amt;
}Am I doing this correctly so far, or what am I not getting? Thank you for your time.
Edited to update code.
Message was edited by:
Alachine

playAgain() : bool
askBet() : int
Payout(amt: void) : void
takeBet(amt:void) : boolThese are methods of the "Game" class, and what is inside parentheses are called parameters.
"void" and "bool" are return types.
public boolean playAgain()
    }In this code you have specified boolean as a return type, so you need to return a value of type bool.
As for the void part, you don't need to return anything.
Code should look like:
public boolean playAgain()
         return true; //Or return false
public void Payout ()
         int amt;
    }You need to get :int amt" in the parameters, and since its voide nothing needs to be returned.
public void Payout (int amt)
    }

Is AOP (Aspect Oriented Programming) concept there in SAP NetWeaver AS ?

Hi all,
Will SAP support AOP....?
If so can anyone tell how to implement AOP in Java to monitor the applications deployed in the NetWeaver Application server...
thanks
Rafi.

Hello,
To my knowledge support of AOP templates has not started yet with SAP.
AOP and Exterme Programming are things which SAP will be moving, but I dont have the dates
regards
Vivek Nidhi

Ready-Made Effects and Object Oriented Timeline

As an actionscript programmer and designer all we need to
effects. But when i searched for ready-effects there is no an
add-on for this. But Adobe must have done this until now. Why there
aren't lot of ready-made effects in Flash?
And one more suggestion to Adobe developers: Every object
must shown as an object in timeline. Not as a layer part. Thus,
programming ability of Flash will arise.

After having problems with spam block software malfunction, I was able recover the following comments to the EXPRESSIONFLOW article Object-flow Programming - Merging Dataflow and Object-Oriented Programming
Written by Zen:
Some combination of data-flow and object-oriented programming, I think,
could make a great impact on sysytem development. However, I see it in
slightly different way than yours....
Written by Matt Holt:
I don't believe NI can get object-flow programming to move far enough
into mainstream that Forbes would cover it. NI has a bit of a
stranglehold on LabVIEW with it's price as compared to say… VS2005. It
seems that by promoting it as "easy to use" that NI may have shot
itself in the foot….
Written by Jim Kring:
Hi Tomi, In my opinion, LabVIEW's native object-oriented programming
capabilities (LabVOOP) do not currently provide a complete tool for
allowing us to implement our OOP system designs. Nearly all of my
system designs require distributed active objects by reference. I think
that National Instruments certainly can evolve LabVIEW to address such
requirements, but I think that it is not a real focus of NI....
If anybody else is missing their comments, I'm sorry I was unable to recover them. Please repost your comments, I appology for the inconvenience.
Tomi Maila

Object oriented programming aspects in Oracle

Dear All,
Can you one explain me the aspects of Object Oriented Programming in Oracle. How to use oops concepts in Oracle Procedures, functions, packages, etc.
Thanks,
Moorthy.GS

Oracle 9i introduces support for inheritance, method overriding and dynamic method dispatch (or "dynamic binding", or "virtual").
A method call is dispatched to the nearest implementation, working back up the inheritance hierarchy from the current or specified type.
See, for example, how we can implement the Template Design Pattern in PL/SQL, using inheritance, method overriding and dynamic method dispatch:
http://www.quest-pipelines.com/pipelines/plsql/tips06.htm#OCTOBER
Oracle 11g introduces support for "super" object-oriented keyword. One attempt to do this in PLSQL 9i/10g:
Calling the Parent Object's Version of an Overridden Method
http://www.quest-pipelines.com/pipelines/plsql/tips03.htm#JUNE
I expect some OO improvements in the future (in Oracle 12oo ...):
1. References between transient objects (instances of objects types) and (then) garbage collector
2. Generic classes (templates, generics) like in Eiffel, C++, Java 5 (PL/SQL was modeled after ADA 83, and ADA 83 has generic packages)
3. Multiple inheritance like in Eiffel (inner classes like in Java - no, please)
4. Design By Contract like in Eiffel (C++ / Java 1.4 assert is not enough)
Design by contract (DBC) is a method whose author is Bertrand Mayer, also maker of OOPL language Eiffel
(Eiffel was designed in 1985, commercialy released in 1986, ISO-standardized in 2006).
Simplified, DBC is based on principle that in each routine (procedure or function) with standard code,
two additional parts – PRECONDITION and POSTCONDITION - need to be asserted.
An additional assertion in class is called INVARIANT.
Contract is based on routine's putting up an obligation to caller (to some other routine)
to satisfy conditions of precondition and conditions of invariant, and hers (called routine's) obligation
to satisfy conditions of postcondition and conditions of invariant.
The object oriented Eiffel programming language was created to implement DBC.
For now, other OO (object-oriented) languages don’t support directly the ideas behind DBC.
However, precondition and postcondition are applicable to many programming languages, both OO and not OO.
Invariants are applicable only in OOPL.
This is my attempt to use DBC methodology (including invariants) in Oracle PL/SQL.
Eiffel class interface (not like Java interface, but more like PL/SQL package specification)
from Bertrand Meyer's book "Object oriented software construction", second edition (OOSC2), 1997, page 390-391:
class interface STACK [G]
creation make
feature -- Initialization
make (n: INTEGER) is -- Alocate stack for a maximum of n elements
    require
      non_negative_capacity: n >= 0
    ensure
      capacity_set: capacity = n
    end
feature -- Access
capacity: INTEGER -- Maximum number of stack elements
count: INTEGER -- Number of stack elements
item: G is -– Top element
    require
      not_empty: not empty
    end
feature -- Status report
empty: BOOLEAN is –- Is stack empty?
    ensure
      empty_definition: Result = (count = 0)
    end
full: BOOLEAN is –- Is stack full?
    ensure
      full_definition: Result = (count = capacity)
    end
feature -- Element change
put (x: G) is –- Add x on top
    require
      not_full: not full
    ensure
      not_empty: not empty
      added_to_top: item = x
      one_more_item: count = old count + 1
    end
remove is -– Remove top element
    require
      not_empty: not empty
    ensure
      not_full: not full
      one_fewer: count = old count - 1
    end
invariant
count_non_negative: 0 <= count
count_bounded: count <= capacity
empty_if_no_elements: empty = (count = 0)
end -– class interface STACK
-- PL/SQL "equivalent":
-- Stack implementation - TABLE of INTEGER.
-- Eiffel has generic classes (like C++ templates and better than Java generics).
-- PL/SQL (now) has not generic classes or generic packages.
CREATE OR REPLACE TYPE array_t AS TABLE OF INTEGER
-- utility package:
CREATE OR REPLACE PACKAGE dbc AS
-- 0 = no check
-- 1 = check preconditions
-- 2 = check preconditions + postconditions
-- 3 = check preconditions + postconditions + invariants
c_no_check                  CONSTANT INTEGER := 0;
c_check_preconditions       CONSTANT INTEGER := 1;
c_check_pre_postconditions CONSTANT INTEGER := 2;
c_check_pre_post_invariants CONSTANT INTEGER := 3;
FUNCTION check_preconditions       RETURN BOOLEAN;
FUNCTION check_pre_postconditions RETURN BOOLEAN;
FUNCTION check_pre_post_invariants RETURN BOOLEAN;
PROCEDURE set_level (p_level INTEGER);
PROCEDURE display_error (p_error VARCHAR2);
END;
CREATE OR REPLACE PACKAGE BODY dbc AS
m_level INTEGER := c_no_check;
FUNCTION check_preconditions RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_preconditions THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
FUNCTION check_pre_postconditions RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_pre_postconditions THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
FUNCTION check_pre_post_invariants RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_pre_post_invariants THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
PROCEDURE set_level (p_level INTEGER) IS
BEGIN
    IF p_level NOT IN
      (c_no_check, c_check_preconditions, c_check_pre_postconditions, c_check_pre_post_invariants)
    THEN
      RAISE_APPLICATION_ERROR (-20000, 'Wrong checking level');
    END IF;
    m_level := p_level;
END;
PROCEDURE display_error (p_error VARCHAR2) IS
BEGIN
    RAISE_APPLICATION_ERROR (-20000, 'ERROR in method ' || p_error);
END;
END;
CREATE OR REPLACE TYPE stack AS OBJECT (
-- Maximum number of stack elements
capacity INTEGER,
-- Number of stack elements
el_count INTEGER,
-- Stack implementation
stack_implementation array_t,
-- Alocate stack for a maximum of n elements
CONSTRUCTOR FUNCTION stack (n INTEGER) RETURN SELF AS RESULT,
-- Top element
MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER,
-- Is stack empty?
MEMBER FUNCTION empty RETURN BOOLEAN,
-- Is stack full?
MEMBER FUNCTION full RETURN BOOLEAN,
-- Add x on top
MEMBER PROCEDURE put (x INTEGER),
-- Remove top element
MEMBER PROCEDURE remove,
-- INVARIANTS
-- Note:
-- If subprogram is declared in an object type body (in PL/SQL 8i/9i/10g)
-- it must be defined in the object type specification too.
MEMBER FUNCTION count_non_negative RETURN BOOLEAN,
MEMBER FUNCTION count_bounded RETURN BOOLEAN,
MEMBER FUNCTION empty_if_no_elements RETURN BOOLEAN,
MEMBER PROCEDURE check_invariants
) NOT FINAL;
CREATE OR REPLACE TYPE BODY stack AS
CONSTRUCTOR FUNCTION stack (n INTEGER) RETURN SELF AS RESULT IS
BEGIN
    IF dbc.check_preconditions AND n < 0 THEN
      dbc.display_error ('stack - PRE');
    END IF;
    check_invariants;
    capacity := n;
    stack_implementation := array_t();
    stack_implementation.EXTEND (n);
    IF dbc.check_pre_postconditions AND capacity <> n THEN
      dbc.display_error ('stack - POST');
    END IF;
    check_invariants;
END;
MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER IS
BEGIN
    IF dbc.check_preconditions AND empty THEN
      dbc.display_error ('item - PRE');
    END IF;
    check_invariants;
    RETURN stack_implementation(el_count);
END;
MEMBER FUNCTION empty RETURN BOOLEAN IS
BEGIN
    IF el_count = 0 THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION full RETURN BOOLEAN IS
BEGIN
    IF el_count = capacity THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER PROCEDURE put (x INTEGER) IS
BEGIN
    IF dbc.check_preconditions AND full THEN
      dbc.display_error ('put - PRE');
    END IF;
    check_invariants;
    el_count := el_count + 1;
    stack_implementation(el_count) := x;
    -- PL/SQL has not Eiffel's OLD
    -- one_more_item: count = old count + 1
    IF dbc.check_pre_postconditions AND (empty OR item <> x) THEN
      dbc.display_error ('put - POST');
    END IF;
    check_invariants;
END;
MEMBER PROCEDURE remove IS BEGIN
    IF dbc.check_preconditions AND empty THEN
      dbc.display_error ('remove - PRE');
    END IF;
    check_invariants;
    el_count := el_count - 1;
    -- PL/SQL has not Eiffel's OLD
    -- one_fewer: count = old count - 1
    IF dbc.check_pre_postconditions AND full THEN
      dbc.display_error ('remove - POST');
    END IF;
    check_invariants;
END;
-- INVARIANTS
MEMBER FUNCTION count_non_negative RETURN BOOLEAN IS
BEGIN
    IF el_count >= 0 THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION count_bounded RETURN BOOLEAN IS
BEGIN
    IF el_count <= capacity THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION empty_if_no_elements RETURN BOOLEAN IS
BEGIN
    IF empty AND (el_count = 0)
       OR
       NOT empty AND (el_count <> 0)
    THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER PROCEDURE check_invariants IS
BEGIN
    IF NOT dbc.check_pre_post_invariants THEN
      RETURN; -- without checking invariants
    END IF;
    IF NOT count_non_negative THEN
      dbc.display_error ('INVARIANT count_non_negative');
    END IF;
    IF NOT count_bounded THEN
      dbc.display_error ('INVARIANT count_bounded');
    END IF;
    IF NOT empty_if_no_elements THEN
      dbc.display_error ('INVARIANT empty_if_no_elements');
    END IF;
END;
END; -- class body STACK
/Regards,
Zlatko Sirotic

Object-oriented programming: state and behaivor

First of all, sorry for my level english.
In Object-Oriented programming, should an object save always some state?
What about session stateless bean service? What is the sense?
These objects have only behaivour and not state.
Perhaps, the sense is that you can send a message to this object, in oposite of a static methods in utility class?
Thanks and regards.

I suppose you could argue that if it doesn't have any state, then it's not really an "object" in the OOP sense, but who cares, really.
Personally, I use state and behavior as a way to help clarify the responsibilities of various classes in the system, and if I see a codebase with a lot of objects with state but no behavior or behavior but no state, then it's a a red flag that it's a messy, poorly-thought-out design (and it usually turns out to be exactly that). The whole point of OOP (IMHO) is encapsulation, and bundling state and behavior together makes things encapsulated (you can prove that state changes only in certain areas in certain circumstances). Encapsulation makes for more easily maintainable code.
It's easy to spot the blue squares in a Mondrian. It's difficult to spot the blue bits in a Pollock. The former is well-encapsulated OOP and the latter is poorly-encapsulated spaghetti code.
That said, it's not the end of the world if you have a static utility class here and there.

Java is pure object oriented programing language or not why?

please clear
java is pure object oriented programing language or not why?

And there is some concepts of object orientation that
Java not implements like: Operator
Overloading and Multiple Heritage. But, i think
that we can live without those features.
And the sucess of Java is a proof of this.I don't believe that operator overloading and multiple inheritance are required aspects of object programming.

A single report can't combine portrait and landscape oriented pages

Post Author: joelo2
CA Forum: Crystal Reports
Hi,
Can a single report in Crystal report XI (version 11.5.8.826) combine portriat and landscape oriented pages like Crystal report 2008? For example, I have one main report with several subreports in the main report. I want one subreport be in portrait page orientation and the other subreports in landscape. Can I do something like that in Crystal report XI version? I even tried writing a small .net program to do this, but it doesn't seem to allow me to do that programmatically either. Please help

Post Author: ngra
CA Forum: Crystal Reports
I'd like to elevate this issue with Crystal Reports XI. There is a critical application which we developed in-house which needs both portrait and landscape orientation in each of the 30,000 plus documents we are sending out every month.If developers in Business Objects are picking this thread up - we need a patch for this limitation - quick. Right now, we are toying with the possibility of exporting the documents into a text format with markers indicating if a page is portrait or landscape. This is to be loaded into a Xerox machine (which costs hundreds of thousands of dollars), where it is mapped automatically to portrait or landscape. Note to Business Objects: This will provide us and countless others with much value. Think 80/20 rule - most bang for your development bucks and value for your customers!

Trying to understand object oriented programming

Hi all,
I'm new to programming and I'm trying to learn C and Objective-C to eventually write an iPhone/iPad app.
I want to make sure I'm understanding some fundamental Object Oriented principles and so I'm starting with a very basic program.
I've produced a class called CartesianPoint which has an x and y variable plus methods to set and return these variables and also a method to calculate the magnitude from the origin.
What I would like to do now is to extend the program to have a CartesianVector class.
I'm a little unsure as to whether a Vector is a subclass of a Point or whether a Point is a subclass of a Vector... or neither?
Secondly, I'm a little unsure of how to implement the vector class to use two point objects. How should the header and implementation files be set up to receive point objects from the main.m program?
I'd like to also try and extend the program to include other ways of defining a vector (i.e. origin, unity vector and magnitude).... and then use the vectors to build 2D shapes.
Many thanks,
Glyn
Message was edited by: GlynC
Message was edited by: GlynC

Hi Glyn -
I agree with William and would vote for "neither". I see a subclass as a specialization of its superclass, not, for example, something contained by its superclass. A container relationship might apply to a subview and its superview, yet the class of the superview could be a specialization of the subview's class so the subview's class might be the parent of the superview's class. The classic example of cat as a subclass of animal (cat:animal) can be misleading if we see the relationship as member:group. Cat is a subclass of animal because it's a specialization.
Also ask, "What's accomplished by making a subclass"? Does the subclass want to use all or most of the parent's instance variables and methods? Could the job be done any other way? Are any of those ways simpler or do they lead to more reusable code?
One of the best examples (from the Cocoa docs?) is about a programmer who needs a specialized array. A newbie might immediately attempt a subclass of NSArray (a rather tricky subclassing job as it happens). In most cases however, the correct solution would be a class which includes an NSArray* type instance variable.
Hope some of the above is helpful!
\- Ray

Sluggish timeline and glitching/freezing program monitor in Premiere Pro CC 8.1

Hi all,
I've recently switched from CS6 to the 2014 Adobe CC due to a student license expiring. I'm also somewhat new to r3d workflow so chances are I may be doing something wrong.
I've worked on one other project with a mix of r3d and DSLR footage in CS6, but this is my first time cutting with red footage in Premiere CC.
*Apologies in advance for the novel, but I figured I'd be as thorough as possible to hopefully help get this issue resolved for myself any anyone else who's experiencing this.*
I'm cutting a 9:30 "party mix" in a music video style edit. So far I've had several (seemingly random) issues and glitches, that have been making my life exceptionally difficult and this 10/30 deadline exceptionally scary.
I'm working with content that we captured using exclusively RED Epic Dragon, and Epic Mysterium cameras. We recorded with several different frame rates, with varying resolution, compression, and aspect ratios. Project was set in-camera to 23.976.
Issue #1
I've created a nearly two hour, organized roll of sub-clip selects in a RED R3D 2K 23.976 16x9 timeline, in which i'll use to browse my raw media when sequencing on a timeline stacked directly below.
Often times when pulling clips from one timeline down to the other, the over-all responsiveness of the program will become ultra sluggish. Causing a clip (that's being dragged/placed) to lag heavily, maybe a couple seconds behind my cursor. This issue will often resolve itself after maybe 5 minutes or so, but makes fluid sequencing rather difficult.
Issue #2
The other issue I'm having is a glitchy or completely unresponsive program monitor. Again this issue appears to be totally random, and seems to happen most when I'm deep into some really intense sequencing/ clip arrangement, and scrubbing quickly.
Usually a portion of a single clip (or sometimes a couple clips) will freeze up in the program monitor while I'm scrubbing over them on the timeline. This will sometimes cause them to freeze all together during playback as well as cause surrounding clips to lag a bit (maybe 4-8fps).
I'll scrub back over the problem area and sometimes get a solid green bar halfway through my image, usually right before the program monitor just reads solid black throughout the entire timeline. This issue is temporarily resolved by restarting the program (about every 15-30 minutes).
Issue #3
As I'm scrubbing I'll also experience heavy glitching with both my image and the program monitor GUI itself. However, this issue typically wont affect playback.
I've uploaded a quick camera-phone video of this issue as it's a little tough to describe Program monitor glitch - YouTube
I know the timeline is un-rendered in this sample, (but this issue happens either way).
Two painstaking weeks later, I've finally completed the first pass.
Working on revisions now, and ultimately I'd like to copy paste the sequence into a 4K timeline for before After Effects work and export.
I tried pulling it into a 4K timeline (with playback set to 1/8 res) and the issues stated above got 10x worse.
Sticking to the 2K timeline for now (with playback at 1/4 res)
P.S. I'm also cutting a much simpler corporate project with 5DMKIII footage and having no real issues.
As for my rig,
I'm running Adobe Premiere CC 2014 v8.1
Freshly installed Windows 7 Professional SP1 PC Desktop
Freshly installed Samsung 1TB SSD running my OS and Adobe CC
Intel Core i7-2600k CPU at 3.4GHz (8CPUs) - Watercooled
16GB Ram (3gb allocated for other programs)
Nvidia GeForce GTX 570 4GB GDDR5 - 3.40.62 Drivers installed
Pulling media from 2x 3TB Seagate Barracuda 7200RPM drives, striped at RAID 0
Thanks for reading!
-Sam

So it seems to be behaving slightly better in "Software Only"
Though slightly less frequently, I'm still running into the issues stated above, mostly issue #2.
I also have a new problem to add to this thread as I'm starting to pull clips into After Effects.
First being that (again, seemingly random) dynamic-linked clips decide not to show up on the timeline in AE, and then seem to vanish from the program monitor in Premiere as well.
As you can see in the screenshots attached- After Effects see's the media itself from which the clip came from, however it won't show up in the monitor.
I'm also having issues where I'll render the Premiere project with the dynamic linked clips that DO work, and then as soon as I restart the program, those previews are gone and I have to re-render the the AE Linked comps.

Trying to understand the basic concept of object oriented programming.

I am trying to understand the basic concept of object oriented programming.
Object - a region of storage that define is defined by both state/behavior.
( An object is the actual thing that behavior affects.)
State - Represented by a set of variables and the values they contain.
(Is the location or movement or action that is the goal that the behavior is trying to accomplish.)
Variables- (What does this mean?)
Value - (What does this mean?)
Behavior - Represented by a set of methods and the logic they implement.
( A set of methods that is built up to tell's the how object to change it's state. )
Methods - A procedure that is executed when an object receives a message.
( A very basic comand.For example the method tells the object to move up, another method tells the method to go left. Thus making the object move up/left that combination is the behavior.)
Class - A template from which the objects are created.
( I am very confused on what classes are.)
- The definitions of the words I obtained from the "Osborne Teach Yourself Java". The () statements are how I interperate the Mechanisms (I do not know if Thats what you call them.) interact with each other. I understand my interpretation may be horribly wrong. I will incredibly appreciate all the support I may get from you.
Thank you

Object oriented programming is a replacement for the older idea of procedural programming (you can research procedural programming in google). As I understand it, in procedural programming, you have a step by step set of function calls to accomplish some task. Each function receives a data structure, manipulates it, and passes it to the next function. The problem with this is that each function preforms some action for the overall task and can't easily be reused by some other task. Its also harder to read the flow of what is happening with raw data structures flying all over the place.
In object oriented programming, an object calls a function of another object and receives back, not a data structure, but another object. Objects contain a data structure that can only be accessed by its functions. An object is not so much a sub component of a bigger task, as it is a service that any other task can use for any purpose. Also, when you pass an object to the caller, the caller can ask questions about the data structure via its functions. The developer doesnt have to know what the previous function did to the data by reading up on any documentation, or having to reverse engineer the code.
I suggest the best way of learning this is to code something like a library object.
A library object contains a collection of book objects
A book object contains a collection of chapter objects
A chapter object contains a collection of paragraph objects
A paragraph object contains a collection of sentence objects
A sentence object contains a collection of word objects.
Add functions to each object to provide a service
Example: A library object should have a:
public void addBook(Book book)
public Book getBook(String title)
public boolean isBookInLibrary(String title)
The key is to add functions to provide a service to anyone who uses your object(s)
For example, what functions (service) should a paragraph object provide?
It shouldn't provide a function that tells how many words there are in a sentence. That function belongs to a sentence object.
Lets say you want to add a new chapter to a book. The task is easy to read
if you write your objects well:
Sentence sentence1=new Sentence("It was a dark and stormy night");
Sentence sentence2=new Sentence("Suddenly, a shot ran out");
Paragraph paragraph=new Paragraph();
paragraph.addSentence(sentence1);
paragraph.addSentence(sentence2);
Paragraphs paragraphs=new Paragraphs();
paragraphs.addParagraph(paragraph);
Library library= new Library();
library.getBook("My Novel").addChapter("Chapter 1",paragraphs).
Now, lets say you want to have a word count for the entire book.
The book should ask each chapter how many words it contains.
Each chapter should ask its paragraphs, each paragraph should ask
its sentences. The total of words should ripple up and be tallied at each
stage until it reaches the book. The book can then report the total.
Only the sentence object actually counts words. The other objects just tallies the counts.
Now, where would you assign a librarian? What object(s) and functions would you provide?
If written well, the project is easily extensible.

Object-Oriented Programming

I'm working on a code associated with object-oriented programming:
The StreetAddress class has this constructor:
StreetAddress( String street, String city,
               String state, String zip );
and the following methods:
void SetStreet( String street ); and String GetStreet();
void SetCity( String city); and String GetCity();
void SetState( String state ); and String GetState();
void SetZIP( String zip ); and String GetZIP();
String MailingLabel();.
The last of these returns the mailing address in the following form:
street
city, state zipand this is what i have so far:
public class StretAddress
private String myStreet;
private String myCity;
private String myState;
private String myZip;
public StreetAddress( String street, String city, String state, String zip)
    myStreet = street;
    myCity = city;
    myState = state;
    myZip = zip;
public String getStreet()
      return myStreet;
public void SetStreet( String street )
    myStreet = street;
public String getCity()
      return myCity;
public void SetCity( String city )
    myCiy = city;
public String getState()
     return myState;
public void SetState( String state )
    myState = state;
public String getZip()
    return myZip;
public void SetZip( String zip )
    myZip = zip;
public String MailingLabel()
System.out.println(street \n city, state + " " + zip);
}I have no idea what to do now, can someone please help me with this?

ejp wrote:
personally, i don't think you need all four in order to be object-oriented.Without all four it might be class-based, or object-based, but not object-oriented. See Peter Wegner's paper which defined all this in 1987:
http://www.cse.msu.edu/~stire/cse891f04/wegner.pdf
With all due respect, I find this "definition" more meaningful:
http://www.youtube.com/watch?v=bfx7tvGisbA

Object oriented programming in LabVIEW

Please send this message to everybody who has an opinion about this.
Please try to keep it short, but if you can't control yourselves, let
it all out!
I would like to have your opinions about the nature of Labview and it's
ability to support object oriented programming.
I have a couple of questions to fire the discussion.
1- Do you think that LV was built to support OO Programming?
2- Is OO the only way we have to support large applications, or is it
feasible to support it with a good dataflow architecture including all
the flowcharts and all the data definitions?
3- Is LV going to stay "dataflow" or is it going to become OO?
4- What would be the great benefits of turning LV to OO that we don't
already have w
ith the dataflow approach?
5- My opinion is that trying to implement OO in LabVIEW, is like trying
to
Thank you all for your time.
Sent via Deja.com
http://www.deja.com/

> 1- Do you think that LV was built to support OO Programming?
LV was initially designed in 1983. OOP existed at that point,
but LV wasn't designed to be OO. It was designed to allow
engineers and researchers a simple language appropriate
for controlling their research labs from a computer.
> 2- Is OO the only way we have to support large applications, or is it
> feasible to support it with a good dataflow architecture including all
> the flowcharts and all the data definitions?
OO lends itself to large projects because it provides
abstraction, encapsulation, and organizes code into
modules that can more easily be implemented independent
of one another since they can be specified in finer
detail. Also, the compilers help to enforce the
specifications providing they can be encoded in the
interface between objects.
These OO principles were already a part of big projects
long before there were OO languages. It was just that
the language didn't necessarily have features which
supported it. Similarly, they can be a part of big
projects today despite the language being used.
LV 2 style globals, which as the name suggests were
in use long ago, encapsulate data with an interface.
They disallow arbitrary access to the data and can be
used to enforce correct access. With other functions
layered on top, you get a nice interface to stored data.
Functions and structs/clusters abstract away details.
Building a subVI that does an FFT means that for 99%
of the uses, you don't need any more information except
that this block performs an abstract mathematical function,
an FFT. The implementation can be completely changed
to speed it up or make it more accurate and your code
isn't affected. Its abstract definition still holds, so
your code still works.
There are other things that OO languages bring to the
table that LV, and GOOP don't yet offer. In my opinion,
a few more OO features can be added to LV to allow for
even larger projects in the future provided they are used
well.
Earlier posts pointed out that C++ doesn't guarantee that
a project will succeed. OO features are just another tool,
and the tool can be misused leading to a failed project.
This is true to LV, C, C++, and all other engineering tools.
The key is using the tools at hand to best solve the
problems we face. Not glorifying or blaming the tools for
the state of the project.
> 3- Is LV going to stay "dataflow" or is it going to become OO?
LV is dataflow to the core. The definition of what data
is flowing may be expanded, but it will still be data
flowing down wires from one node to another that accounts
for how the program executes.
One of the limitations of the current GOOP is that all
objects are dealt with by a reference. By adding
language features, objects could be made to flow down
the wire, just like strings and arrays, meaning that
branching a wire doesn't lead to side-effects,
and there is no need to dispose objects.
> 4- What would be the great benefits of turning LV to OO that we don't
> already have with the dataflow approach?
Remember when LV didn't have typedefs? It was easy for
a cluster datatype to change once a project was underway.
That usually led to lots of edits on other panels to get
them back in synch. Without the unbundle by name, you
then went through the diagrams fixing all of the bundlers
and unbundlers to have the right number of terminals.
Changing the order of the cluster was even worse since
the diagrams may not bread, they might just access the
wrong field instead.
In many respects, an object is just another step along the
same path. An object is a typedef that can have code
associated with it for access -- maybe like Array and
Cluster Tools. Some of the typedef contents might be
publicly accessable, like now, while other elements are
hidden, only available to the implementation of the
typedef. That would force the user to use your functions
to manipulate things rather than hacking away at the
typedef contents. As an example, a LV string is really
just a cluster of size and characters. Since the diagram
can only modify the string using the string functions, you
never get the size and characters out of synch. That is
until you take it into LV generated code, a DLL or CIN
where you have access to the inner fields.
A related problem is that current typedefs are transparent
to built-in LV functions. If your typedef is just some
numbers, LV will be happy to perform arithmetic on your
typedef. Maybe this is what you want, but if this doesn't
make sense on your typedef, then your left with adding a
Boolean or a string so that the arithmetic isn't allowed.
Ideally, you would be able to state that = makes sense, >
and < don't, + and - only operates on the first numeric, and
* is something that you implement yourself. There would be
some safeguards so that the user of your typedef, which
includes you, wouldn't accidentally mangle the typedef
contents.
These may not seem like much at first, but they allow for
much more abstraction and better encapsulation. Finally,
there is a technique called inheritance that allows for
similar objects to be acted on by common code in one
location, and by specific code in another location depending
on which type of object is actually there at runtime.
This of usually done today by switching out on some inner
tag and dealing with each type in its own diagram. This
works fine until projects get large and teams get large.
Inheritance is a different way of implementing the exact
same thing that usually works much better for bigger teams
and bigger projects.
> 5- My opinion is that trying to implement OO in LabVIEW, is like trying
> to
Is this a fill-in-the blank question? It is difficult today
because the LV language doesn't yet support OO very well.
Early C++ was implemented on top of C using just a bunch
of macros and the preprocessor to mangle the C++ back into
C so that it could be compiled and run. Debugging was
done on practically unreadable text that vaguely resembled
your original code. By comparison, GOOP actually looks
pretty good. It is written entirely on top of the current
LV language and makes clever use of things like datalog
refnums to make strict types.
Over time I think GOOP will mature, and like typedefs,
some users will come to rely on it in a big way.
Other users will hopefully not even notice that anything
changed. If their project grows in complexity and they
need another tool to manage things, it will be just
another feature that helps them to get useful things done.
Greg McKaskle

BPEL and Aspect Oriented Programming ?

Similar Messages

Maybe you are looking for