text:
Tuesday, November 06, 2007
On birth and busy-ness
The complicated reasons aren't so easy to explain. Maybe one of these days I'll come on here and explain a little more about what's going on, but for now let's just say it's a bit of a personal spiritual journey, combined with the birthing of a new creative "baby".
This figurative birthing process has made me reminisce about my literal birthing experiences - the three that resulted in my beautiful daughters, and the one that resulted in my beautiful, though lifeless, son. The memory that's been with me today is that of my coming into motherhood experience.
Nikki had a really difficult entry into this world. I still find myself - nearly a dozen years later - getting a little emotional when I remember the intensity, pain, frustration, worry, seamingly endless agony, and yet ultimate joy of that experience (and a whole lot of emotions in between). It started out with me being induced because a fetal assessment showed (rather incorrectly) that she was a little on the small side and that my fluids were getting low (a week after she was due). Inducement led to hours of waiting for something to happen, followed by nearly 36 hours of labour (there's the "endless" part), three hours of heavy duty pushing, followed by an urgent call to the only obstetrician in the city who could do the necessary procedure to to deliver her without a c-section, lots of tearing and stitches, and then finding out that she had to be rushed away from me to be treated with antibiotics because there was a risk of infection.
When she was finally born, after all those hours of pushing, I had gone almost completely (though thankfully temporarily) blind. It turns out the agony of pushing for that long can mess up the muscles around your eyes so badly your vision gets messed up. They put my baby on my chest, but I had to rely on Marcel's description of her and the touch of my fingers to know anything about how she looked.
Not long afterwards, she was whisked away, and because it was late and we all needed rest, I was returned to my room and Marcel and my mom left the hospital.
The memory that has been clinging to me today has been not so much about the delivery but about what happened later that night. I awoke in the middle of the night and was suddenly filled with the most intense body-aching loneliness I had ever felt. My family had gone, and the baby that had moved in my womb for the last nine months was way down the hall behind nursery room glass. I'd given birth to her, gone through nearly unbearable pain to introduce her to the world, but I didn't even know what she looked like.
My eyesight had returned and I knew I HAD to see her. I knew it with the deepest longing imaginable. But I was in so much pain, I couldn't even figure out how to shuffle my body up in the bed in order to reach the call button to get the nurse.
But there is little that can get in the way of a mother who needs to see her child. I struggled for what seemed like an eternity, but I somehow managed to get my body up off the bed and down the hall. The nurses looked up in amazement as I passed them and entered the nursery. I'm sure there was a rather desparate look in my bloodshot eyes.
I found my baby. And I wept at her loveliness. She looked so tiny and vulnerable, hooked up to all kinds of wires and hoses, lying nearly naked in an incubator. Truly, she was not a beautiful baby - after what she went through to get into the world, it's hardly surprising - but she was the most beautiful thing I had ever seen.
I reached out and touched her skin and knew that I had fallen completely and irreversibly in love.
I'm not sure why this is on my mind today, but I'm sure it has something to do with this creative birthing process. Some of it is painful, and it's possible that what comes of it may never "live", but at this point, I have to believe it will be beautiful.
12 comments:
- Michele said...
i can't wait to hear more.
- Kristin said...
Oh, I'm believing right along side you! This phrase really sticks out to me - "there is little that can get in the way of a mother who needs to see her child" - and I can't help but think it's a kind of blessing for your very self...like a little fortune cookie paper that you're shocked to discover was penned by your own hand. Many blessings on this new baby, and on the spiritual things that are moving in you, too.
- Gina said...
I wish you the best of luck on your endeavors, my dear.
And what a touching story.
- Amanda said...
How wonderful is this post?? Truly wonderful.
I remember having very similar feelings. (although, I was glad that 8 1/2 pound baby was out because I had kidney stones yet to deal with....)But I felt this story and want to thank you for sharing. A hundred years could pass, but no mother is going to forget the way she felt the very first time she saw her baby.
Also, good luck with your creative birthing. I'd say it's easier than childbirth, but I've not much experience with it.
- Vicki said...
i love it when you lay it all out like this. somehow take raw emotions every woman has felt and put them into words that fit perfect!
By the way, you won a fridge magnet! Come claim your prize!
- Karmyn R said...
What a wonderful sentiment!
- Anvilcloud said...
I remember staring through the nursery window and falling in love with Thesha.
- Hope said...
I find myself in a strange "antsy" phase of my life these days, searching for a new direction. I have many ideas that have been on the back burner, and I keep asking myself if not now, when.
I am sure that whatever you pursue will be exciting.
- Liz said...
I could have written that same comment that Hope wrote. Good luck to you Heather!
And that feeling of loneliness is one that I remember well and had a hard time explaining to people. Nobody warns you about how hard it is to not feel that baby inside you any more.
- Tiggerlane said...
Wow...what a moving post.
I remember giving birth (fairly easily, compared to your experience), at 3:20AM. I was allowed a brief look, and then I passed out from sheer exhaustion...
When I finally awoke at 7:00AM, I was overwhelmed with the urge TO SEE HER. I wanted her RIGHT THEN AND THERE. My husband had left to prepare our home, car, etc., and I was all alone in that hospital bed. I was strong enough to hit the call button, and insisted she be brought to me. I finally felt complete again, when they brought her.
Thanks for sharing your story.
- Pamela said...
long past my bedtime, but worth staying up to read. and crying, too.
- Linda said...
I too am looking forward to the result of your new birthing process.
And having had children, I understand that absolute, single focussed need to see your baby.


text:
Enrolling my girls into the creative drama and public speaking program at Power Speakers must have been one of the best things that had happened to them. My older one was shy and this medium helped her open up.. Taruna is great with kids. They learned and are continuing to learn a lot and it helps them develop into well rounded, articulate, and expressive personalities.
When the students of Power Speakers NJ arrived at our High School we were, at first, skeptical whether these very young debaters would be able to speak in front of a large audience of teenagers. However, not only did these young debaters grasp our interest and attention, they also spoke in a very engaging manner which captivated all the members of North JSA. Their instructor, Taruna, has done a great job in transforming inexperienced shy children into confident young public speakers. We wish the best for the student of Power Speakers NJ and hope they pursue their interest in public speaking.
We were not sure what to expect when we enrolled our 8yr old in the class. From the 1st class she loved it and looks forward to it. Taruna has the ability to easily connect with the children. Our very anxious public speaker has gained a lot of confidence and clarity of thought over the past few months. All this done in an informal, fun and encouraging way promoting self confidence and gaining essential skills as they grow. I would recommend that every child avail this opportunity!
Mr. Benjamin Franklin said it perfectly – involve me and I learn…Start your children young in a speech class, and watch their imagination take flight. Creative dramatization, story building, and public speaking are just some of the activities woven into this program for children ages 5 to 7.Read More
Those children that continue with the program or those children 8 to 10 years just starting the program will begin with development and delivery of speech at this stage. We will teach the entire speech map – piece by piece to your child, honing your child's skills through different planned activities.Read More
This program encourages students to dig deeper into their experiences and take the craft of public speaking to a higher level using pathos, ethos, logos. This program empowers the students by:Read More
July 14, 2016: Lawrence Library
July 16, 2016: West Windsor Library
July 21, 2016: Lawrence Library
July 28, 2016: Lawrence Library
August 6, 2016: Robinsville Library
August 27, 2016: Lawrence LibraryRead More
May 5, 2016: Girls Scout
May 21, 2016: West Windsor Library
May 28, 2016: Atrium Senior Living
June 4, 2016: Atrium Senior Living
June 11, 2016: West Windsor Library
June 12, 2016: Plainsboro LibraryRead More
March 26, 2016: West Windsor Library
April 17, 2016: Plainsboro Library
April 23, 2016: West Windsor LibraryRead More

subset: commoncrawl


text:
Cha Cha Cha Trailer (1989)
20 January 1989 91 mins
A lawyer pays a visit to Matti Ojanperä (Matti Pellonpää), a bum living under a bridge in the Helsinki harbour, to inform him that he is about to inherit an American aunt of his. The sum 1,000,000 Fmk would be his, if only he meets the qualifications set by his aunt. He must show that he is capable of 'living properly' and possessing a 'respectable occupation and a family he can support'. Otherwise the money would go to a foundation the chairman of which the lawyer himself happens to be!
Watch the official Cha Cha Cha 1989 trailer in HD below or find more Cha Cha Cha videos on Vidimovie.


text:
Do you wish to play the guitar? Do you want to learn something that many around the world love doing? If you answered yes, you are in the right place. This information will help you get the ball rolling when it comes to learning guitar.
Don't try to learn everything at once. Be specific and steady, that's the key to learning. Save some time for practicing each day and you will soon see improvements in your guitar playing skills and always check your guitar guide for each day.
Figure out how to stay invested in the process. When it comes to learning how to play guitar, establish short-term as well as long-term goals. Find a buddy who is also interested in learning and practice together. Reward yourself near the week's end after successful daily practices. Most things that are worth doing aren't simple, and you should keep that in mind.
If you would like to play a guitar, buy one. If you have no guitar, you won't be able to practice. It's important to have your guitar properly tuned, or it will sound incorrect.
It is best for you to learn guitar tabs and musical notation. Music theory is great for teaching you about scales and chords. Spend time learning each string's note name, and also the note names for every fret. You will find this knowledge serves you well as you play riffs and melody.
When you begin learning the guitar, do all you can to obtain a high-quality instrument for the purposes of practicing. Rent one from a friend if you do not have the money. A good guitar will make a huge difference in the way your songs sound when you learn guitar that way you get to appreciate good sounds.
Build up calluses on your fingers when practicing guitar. Calluses will help the pain you get on your fingers from regular practice disappear. While this won't happen overnight, but consistent practice will help. You can also buy products for this purpose.
Best way to learn to play the guitar be sure to work on learning the correct names for each element of the instrument itself. At some point you will find that you need to read something about the guitar itself, and knowing all the guitar's parts will help you understand what you're reading. In the end, it will help you be the best guitar player you can be.
The first thing you should do is familiarize yourself with the various parts of your guitar. This will help the learning process because you must understand the instrument to grasp scales, chords and the different strings. Here is a book I highly recommend, truly you have to start from the chords if you want to really learn and retain the information longer in order to proceed:
When learning songs, you should try playing them in different keys. When you learn to play one tune in different keys, you can start to understand different chords. You'll also understand music better. This will improve your overall talent.
As you have now read, there is a lot to know about playing the guitar. However, it's not something that will be too hard to master. Stick with it, and you will find over time that you will be playing enjoyable songs in no time. Utilize the information you just read to get you started. When learning guitar study many videos that way you will get to develop a style that you feel comfortable with.


text:
|Publication number
|Publication type
|Application number
|Publication date
|Dec 10, 2002
|Filing date
|Feb 17, 1999
|Priority date
|Jan 2, 1996
|Fee status
|Also published as
|Publication number
|David C. Boutcher
|Original Assignee
|International Business Machines Corporation
|Export Citation
|BiBTeX, EndNote, RefMan
|Patent Citations (16), Non-Patent Citations (3), Referenced by (59), Classifications (7), Legal Events (4)
|External Links: USPTO, USPTO Assignment, Espacenet
This application is a Continuation of application Ser. No. 08/582,141, filed Jan. 2, 1996, now U.S. Pat. No. 5,915,112, which application(s) are incorporated herein by reference.
The invention generally relates to distributed computer systems, and in particular, relates to supporting multiple versions of client and server computer processes existing in distributed computer systems.
Distributed computer systems have become more widespread as interconnected computer networks and the like have proliferated. Distributed computer systems are characterized by the sharing of resources and the use of multiple computer "processes" running on multiple computer systems to cooperatively perform tasks, where computer "processes" are routines or threads running or executing on computer systems, e.g., as part of larger applications or programs. Distributed operating principles may be found, for example, on Local Area Networks (LAN's), Wide Area Networks (WAN's), and on global distributed networks such as the Internet.
One way in which multiple computer processes may cooperatively perform tasks is under a "client-server" relationship. In such a relationship, a "client" or calling computer process issues or sends a request for a remote procedure to a "server" or receiving computer process which executes the procedure. It will be appreciated that while one computer process may function as a client when it issues a procedure request and another may function as a server when it executes the procedure, any computer process may function as both a client and a server in different capacities.
A preferred manner of passing remote procedure requests between clients and servers is through Remote Procedure Calls (RPC's), which are typically defined using a remote procedure interface, e.g., using a specific Interface Definition Language (IDL). IDL's have been developed, for example, for the Open Systems Foundation Distributed Computing Environment (OSF DCE), the Windows 95 and Windows NT operating systems, the UNIX operating system, and the Sun Network File System (NFS), among others.
As new functionality is implemented in computer processes and environments, however, remote procedure interfaces often may be enhanced to support the new functionality. As is common in the industry, enhancements to a remote procedure interface, like any computer program or application, are embodied in a new "version" of the interface.
To support a new version of a remote procedure interface, both the client and server utilizing the interface must support the new version. In many distributed computer systems, however, it is impossible or impractical to upgrade all clients and servers at the same time to a new version of a remote procedure interface. This may be due to cost constraints (e.g., in internal networks) or due to lack of control (e.g., in shared or public networks). Consequently, multiple versions of an interface may exist over a network.
The only manner used heretofore to handle multiple interface versions is to allow servers to support multiple versions, with clients supporting only single versions. In such implementations, it is incumbent for the RPC runtime code on a server to detect the version of the interface used by a client and direct any requests to appropriate versions of routines on the server. However, if a client issues a request using a version not supported by the server, the request fails.
These implementations are thus not capable of handling the situation of when a client is upgraded to a new version of an interface before a server. Furthermore, this situation is exacerbated in the situation where computer processes function as both clients and servers, where conventional implementations would require all processes to be upgraded at the same time.
Therefore, a substantial need has arisen for a manner of supporting multiple versions of a remote procedure interface in a distributed computer system, which permits both clients and servers to seamlessly support multiple versions coexisting within the system.
The invention addressees these and other problems associated with the prior art in providing an extended remote procedure interface which maps each remote procedure defined in the interface to prior versions of the remote procedure. This enables client computer processes to utilize a version map from the interface when requesting execution of remote procedures so that the requests are in formats supported by the server computer processes executing the remote procedures, regardless of the versions of the remote procedure interface in the client and server processes. This is in direct contrast to conventional systems, as the preferred remote procedure interfaces enable clients, and not just servers, to support multiple versions of an interface.
By mapping remote procedures to prior versions of the same, the manner or order in which clients and servers are upgraded in a distributed computer system are no longer critical, which is particularly beneficial in shared and public network environments where control over interface versions is all but impossible. Moreover, as remote procedure interfaces and distributed computing applications are enhanced and additional versions are supported, new applications may be implemented with less effort and with greater backward compatibility and seamless integration into existing systems. Further, often much of the underlying code can still remain the same, thereby freeing the interface from particular computer architectures and making the interface less platform-dependent.
Therefore, in accordance with one aspect of the invention a computer system is provided comprising a client computer process for requesting a remote procedure to be executed by a server computer process external to the client computer process. The client computer process supports a first version of the remote procedure and the server computer process supports a second version of the remote procedure. The client computer process includes a mapper that maps the first version of the remote procedure to the second version of the remote procedure if the server computer process does not support the first version of the remote procedure; and a requester, coupled to the mapper, that requests the server computer process to execute the second version of the remote procedure.
According to an additional aspect of the invention, a distributed computer system is provided, which includes first and second computer systems coupled through a network; a remote procedure interface residing in the first computer system, the remote procedure interface defining a first version of a remote procedure and a version map that maps the first version of the remote procedure to a second version of the remote procedure; and a request handler, residing in the first computer system and having access to the remote procedure interface, that requests execution of the remote procedure on a computer process on the second computer system, wherein the request handler utilizes the version map in the remote procedure interface to request execution of the second version of the remote procedure if the computer process on the second computer system does not support the first version of the remote procedure.
In accordance with a further aspect of the invention, there is provided a method for requesting in a first computer process a remote procedure to be executed by a second computer process. The method includes the steps of determining in the first computer process whether the second computer process supports a first version of the remote procedure which is compatible with the first computer process; and if the second computer process does not support the first version of the remote procedure: mapping the first version of the remote procedure to a second version of the remote procedure which is compatible with the second computer process; and requesting the second computer process to execute the second version of the remote procedure.
According to another aspect of the invention, a program storage device is provided which readable by a first computer process. The program storage device tangibly embodies a program of instructions executable by the first computer process to request a remote procedure to be executed by a second computer process. The program includes a version map that maps a first version of a remote procedure to a second version of the remote procedure which is compatible with the second computer process; and a request handler that issues a request to execute the remote procedure on the second computer process, wherein the request handler utilizes the version map to issue a request to execute the second version of the remote procedure if the second computer process does not support the first version of the remote procedure.
According to a further aspect of the invention, a method is provided for transmitting a program product to a computer system. The method includes the steps of establishing a connection with the computer system; and transmitting the program product to the computer system, the program product being executable by a first computer process on the computer system to request execution of a remote procedure by a second computer process. The program product includes a version map that maps a first version of a remote procedure to a second version of the remote procedure which is compatible with the second computer process; and a request handler that issues a request to execute the remote procedure on the second computer process, wherein the request handler utilizes the version map to issue a request to execute the second version of the remote procedure if the second computer process does not support the first version of the remote procedure.
These and other advantages and features, which characterize the invention, are set forth in the claims annexed hereto and forming a further part hereof. However, for a better understanding of the invention, and the advantages and objectives attained by its use, reference should be made to the Drawing, and to the accompanying descriptive matter, in which there are described preferred embodiments of the invention.
FIG. 1 is a functional block diagram illustrating the principle hardware components in a distributed computer system consistent with the principles of the invention.
FIG. 2 is a functional block diagram illustrating the principle software components of a client computer system and a server computer system in the distributed computer system of FIG. 1.
FIG. 3 is an exemplary remote procedure interface defined in an interface definition language (IDL).
FIG. 4 is an extension of the remote procedure interface of FIG. 3, incorporating version mapping consistent with the principles of the invention.
FIG. 5 is a flowchart illustrating the program. flow for a preferred HANDLE REQUEST routine executing on the client computer system of FIG. 2.
FIG. 6 is a flowchart illustrating the program flow for the MAP REQUEST routine of FIG. 5.
FIG. 7 is a flowchart illustrating the program flow of an alternate HANDLE REQUEST routine to that of FIG. 5, primarily for use in distributed computer systems not having network directories.
FIG. 8 is a flowchart illustrating the program flow of the RESEND REQUEST routine of FIG. 7.
Turning to the Drawing, wherein like numbers denote like parts throughout the several views, FIG. 1 shows an exemplary distributed computer system 1 consistent with the principles of the invention. System 1 includes a plurality of computer processes or systems (e.g., computer systems 10, 20 and 60) coupled through a local area network (LAN) 5. Any number of computer systems may be coupled through network 5; however, for the purposes of illustration, only systems 10 and 60, which function as client systems, and system 20, which functions as a server system, are shown in FIG. 1.
FIG. 1 also illustrates a wide area network (WAN) 7 between server system 20 and an additional server system 62 (which includes its own LAN 8 interconnecting the server to a client system 61). As is evident from this figure, enumerable network connections, including LAN, WAN, global, and combinations thereof, with any number of client and server computer systems, may be envisioned in a distributed computer system. Thus, the invention should not be limited to any particular arrangement of computer systems across any particular network configuration.
Client system 10 includes a central processing unit (CPU) 11, a non-volatile program storage space such as read only memory (ROM) 13, a workspace such as random access memory (RAM) 12, a mass storage device such as a hard disk 15, and a removable storage device such as a floppy drive 14, or alternatively a CD-ROM reader or tape drive. Similarly, server system 20 includes a CPU 21, a ROM 23, a RAM 22, a plurality of mass storage devices 24, and a removable storage device 25. Systems 60, 61 and 62 may also have a similar configurations.
The components shown for the above computer systems are generic to many types of computer systems. In some cases, server systems 20 and 62 may be implemented in larger or more powerful systems than client systems 10, 60 and 61. However, this is by no means indicative of all distributed computer systems, and therefore it should be appreciated that any of the above systems 10, 20, 60, 61 and 62 may be implemented in enumerable types of computer systems having various configurations of hardware, software, storage devices, and other peripheral components, including personal computers, workstations, network servers, minicomputers, mainframe computers, supercomputers, etc.
FIG. 2 illustrates the software components of systems 10 and 20 functionally connected across network 5. The functional hierarchy of system 10 includes an operating system 16 operating on CPU 11, with various communications programming interfaces (CPIs) being designated at 17. Applications or computer processes, e.g., process 30, execute on top of this platform, and communication through network 5 is handled by a network interface 18. Similar to system 10, the functional hierarchy of system 20 includes an operating system 26 operating on CPU 21, communications programming interfaces (CPIs) 27, network interface 28 and processes 38 and 40.
Elements 16, 17 and 18 of system 10, as well as elements 26, 27 and 28 of system 20, may be implemented under many different operating environments, including UNIX, OS/400, MVS, MS-DOS, OS/2, Windows, and the Macintosh operating system, among others, with network communication being handled in various network protocols such as IPX/SPX, TCP/IP, IBM Systems Network Architecture (SNA), among others. The organization of the software within client and server systems such as systems 10 and 20 is well understood in the art, and will vary for different applications.
It will be appreciated that the various applications, programs, computer processes and other supporting software (e.g., the operating systems and interfaces) are resident at different times on one or more "program storage devices." As used herein, the term "program storage device" may include any device or apparatus capable of storing information such as data or program code either in a volatile or non-volatile manner. Accordingly, a program storage device may comprise memory devices such as RAMs, ROMs, EPROMs, processor and cache memories, flash memories, customized integrated circuits, etc., as well as fixed or removable mass storage medias such as magnetic disks (fixed or removable), CD-ROMs, magnetic tape, etc. In addition, it will be appreciated that the various applications, programs, computer processes and other supporting software (generically "program products") may be transferred or downloaded to a computer system via network or modem in lieu of being provided on a storage media such as a floppy disk or CD-ROM, typically by first establishing a connection between the computer system and a server-type computer, and thereafter transmitting the program product to the computer system. Thus, it will be appreciated that a "program storage device" may also include any of the aforementioned memory and storage media of a server-type computer (e.g., a bulletin board or ftp site) which downloads or transfers a program product to other computer systems but does not actually execute the downloaded or transferred program product.
As discussed above, the preferred application of the invention is in the handling of remote procedure calls between client and server computer processes resident on separate computer systems coupled through a network in a distributed computer system. To illustrate this application, FIG. 2 shows a client process 30 executing on system 10 which issues a remote procedure call (designated by arrow 50 which passes through the different low level functional components which generally handle the call) across network 5 to a server process 40 executing on system 20.
Another preferred application of the invention is in handling external or remote procedure requests between multiple computer processes operating on the same computer or processing system, e.g., separate applications or programs running concurrently on a multi-tasking computer system. To illustrate this application, FIG. 2 shows another client process 38 executing on system 20 which is able to issue a remote procedure request (designated by arrow 52 and utilizing CPIs 27) internally within system 20 to server process 40 also resident on system 20. Accordingly, it will be appreciated that the terms "remote procedure" and "remote procedure request" when used herein may relate to client and server processes which either reside on the same or different computer systems. In addition, although the much of the remaining discussion herein will focus specifically on remote procedure calls (RPC's), one skilled in the art will appreciate that the discussion will also apply to remote procedure requests between processes running on a single computer system.
Moreover, it will also be appreciated that while individual computer processes will hereinafter be referred to as "clients" or "servers", such processes may function as both clients and servers in some applications.
Implementation of Remote Procedures in Distributed Computer Systems
As discussed above, remote procedure calls provide a mechanism for allowing a program or computer process running on one computer system to call a subroutine which is resident on a remote system. Thus, to illustrate the workings of the preferred embodiments of the invention, FIG. 2 shows one implementation of a distributed computer system wherein client system 10 issues a remote procedure call (designated as 50) to server system 20.
Consistent with the trend to implement modern computer programs using a structured, procedural approach, remote procedure calls are preferably implemented with only a minimum of additional design and implementation by an applications programmer. In many distributed computer systems, the primary implementation of remote procedure calls is provided through four components which are illustrated in FIG. 2. First, a pair of "stub" components, e.g., client stub 34 and server stub 44, implement the specific procedures which are to be sent across network 5. For example, the RPC stubs "marshall" and "unmarshall" the data comprising an RPC call and result to and from appropriate data packets or streams suitable for being sent across the network. The RPC stubs may also process transmitted and received data into compatible formats for their respective systems.
Another pair of procedures, e.g., client runtime 36 and server mainline 42, are generic routines which typically handle many of the low level functions that are independent of particular RPC's. These functions may include, for example, the actual transmission and receipt of data packets across the network, among others.
One purpose of the aforementioned configuration is to free an applications programmer from having to write much of the specific code necessary to implement RPC's. Another purpose of the configuration is to make RPC applications as platform independent as possible.
In general, to develop an RPC application, the desired interface between a client and a server is defined using an interface definition language (IDL) which specifies the desired remote procedures and the data structures, constants, and parameters required for implementation of the procedures. For example, FIG. 3 illustrates a typical RPC interface, which generally has the form:
Next, the interface file is compiled using an IDL compiler. Typically, compilation of the interface file results in four files. On the client system, client stub and client header files are generated. The client stub file is a compiled source file which is linked with the client runtime code to provide access to the remote procedures. The client header is a header file containing prototypes, data structures and constants generated from the IDL file, and defining the format for calling the remote procedures in the client system.
Similarly, two files are generated on the server system, including a server stub file and a server header file. The server stub file is a compiled source file, linked with the server, that formats parameters prior to calling the actual routines. The server header file is a header file containing the prototypes, data structures and constants generated from the IDL file, and defining the calling format of the routines of the server.
The resulting client and server stub files therefore generally contain all the code necessary to collect all the client parameters and package them into a buffer, transmit the buffer across the network, unpack the buffer into a format the server understands, call the routines on the server, and return any results to the client. The header files are for use by the application programmer when coding the application, but they do not form components of the final executable application code.
Once the aforementioned files have been compiled, the client and server portions of the code are generated for the RPC application. The client portion of code (e.g., main program 32 of system 10) should be written to call the desired remote procedures using the prototypes defined in the client header file. Similarly, the server portion of code should provide the actual remote procedure routines (e.g., routines 46, 48 on system 20) that match the prototype in the server header file. The client and server header files need not be exactly the same due to type conversions, but they will typically be very close.
To complete an RPC application, the application code is compiled and linked to the respective compiled stub files. The respective client and server object code are then ready to be installed on suitable client and server computer systems.
A number of interface definition languages exist, e.g., for the Open Systems Foundation Distributed Computing Environment (OSF DCE), the Windows 95 and Windows NT operating systems, the UNIX operating system, and the Sun Network File System (NFS), among others. Any interface definition language may be modified to implement the invention as will be described below. One UNIX RPC interface is described, for example, in "UNIX System V Release 4 Programmer's Guide: Networking Interfaces" available from UNIX Systems Laboratories. The OSF DCE RPC interface is described, for example, in "OSF DCE Application Development Guide" available from the Open Software Foundation. Other known systems and interfaces may also be used. Interfaces may be implemented in the C programming language or one of its derivatives such as C++, although other programming languages, including FORTRAN, may also be used.
The above discussion pertaining to programming and implementing distributed computer systems using remote procedure calls is generally understood in the art. It will be appreciated that the particular implementations may vary for different systems. Furthermore, as the general operation of distributed computer systems and the like is generally known, the particular implementation of the RPC client and server code need not be discussed in greater detail for a complete understanding of the invention.
Moreover, it will be appreciated that, in preferred embodiments of the invention, a remote procedure interface is utilized to "define" the remote procedures. By "define", what is meant is the interface provides a "prototypes" or other suitable templates which sets forth details such as procedure name, expected sent and returned parameters, constants and data structures, etc. which permit a program or routine running on the calling process to send an appropriate remote procedure request that will be recognized and understood by the remote computer process that actually executes the requested remote procedure. As such, it will also be appreciated that a remote procedure interface does not "exist" in a computer process in the format shown in FIGS. 3 or 4, for example. Instead, the remote procedure interface is primarily a tool or language which defines the protocol for a programmer to use when writing the code which calls remote procedures from a calling computer process. The remote procedure interface, however, may be considered to "exist" in an executing computer process during runtime, since the stub file in the computer process of the preferred embodiments contains the executable code that expects and implements a given remote procedure interface when receiving and formatting remote procedure requests from a calling process.
Implementation of Version Mapping into RPC Framework
As discussed above, upgrading an RPC application executing on multiple computers in a distributed computer system is often problematic due to a difficulty in upgrading all client and server processes or components of the application. While conventional RPC implementations will allow a server to support multiple versions, these implementations do not support the case where an RPC client is upgraded to a newer version of an interface before the server is upgraded.
This problem associated with conventional implementations is addressed herein by extending the interface definition language to include the concept of a "version map" such as version map 35 illustrated functionally in FIG. 2. A version map, which is preferably resident in the client stub (e.g., client stub 34 in system. 10) provides a formal statement of how older versions of a procedure should be handled, thereby freeing the caller of an RPC routine from specifically addressing which version of the routine has to be called based upon the versions of the interface resident on the client and server computer systems.
Generally, the kinds of mapping that may be required between versions may include transforming parameters prior to their being sent to a remote procedure, transforming parameters that are returned from a remote procedure, providing default values for parameters that do not exist in one version or the other, calling a substitute version of a procedure, and rejecting the call if certain conditions exist, among others. In general, the version map may be considered as a table that is generated as part of the client stub that states, for each procedure, how to map that procedure to other versions of the interface. It will be appreciated that the concept of the version map can also be extended to other constructs in an IDL definition, including objects and data structures, for example.
Many different version mappings may be supported in an interface consistent with the invention. As one example, in system 1 of FIG. 2, version map 35 supports at least three different "mappings" for a version of a remote procedure in the interface definition. The mappings are defined in an extended version of a remote procedure interface, e.g., using the statement:
A first mapping is a direct mapping, e.g., using the keyword "DIRECT" (such as for the version 1.1 mapping of Routine C in version map 35). The use of this keyword indicates that the procedure can be mapped directly between the two versions with no conversion. The runtime simply calls the routine in the mapped version without modification.
A second mapping is useful when two versions of a procedure differ only in the numbers and/or names of parameters. This mapping may be implemented, for example, using the keyword "BYNAME" (such as for the version 1.0 mapping of Routine B in version map 35). Under this mapping, a procedure can be mapped simply by matching parameters by name. Unmatched parameters may default to a default value such as zero.
A third mapping may be useful when greater modifications are required to execute a procedure in an earlier version. In this case, the keyword may be the name of a mapping procedure (such as the CallRoutineDV1( ) routine for the version 1.0 mapping for Routine A in version map 35). Under this mapping, the mapping procedure must be separately coded to perform any of the necessary functions required to call the earlier version procedure. This may include, for example, calling a substitute remote procedure, adding or removing parameters, setting specific defaults for parameters, or handling any other situation which requires more modification than simply matching parameters by name.
In addition to the above mappings, an additional keyword, such as "NOMAP", may be used to indicate when no mapping exists for a particular version (such as the version 1.0 map for Routine C in version map 35). In this case, the RPC runtime may indicate a failed call due to the inability to map a call to the earlier routine.
A failed call may also be indicated by the RPC runtime if a particular version is not supported by the interface (i.e., when no keywords are found in the version map for a particular version). Alternatively, the RPC runtime may attempt to handle earlier versions in different manners, e.g., by using the mapping from the earliest supported version for the interface.
As another example, FIG. 4 shows an extended RPC interface, which has been upgraded from the interface shown in FIG. 3 to include a version 2.0 interface. Each remote procedure listed in the version 2.0 interface includes a "versionmap( )" parameter to map each routine to prior versions.
In this example, longer user names (previously 20, now 30) are supported in version 2.0, and a new function testUID( ) is defined. Each defined procedure in the new version of the interface states how to map back to the previous version. Given the longer user names, the getUser( ) and setUser( ) functions are mapped by name using the keyword "BYNAME". The getUIDfromName( ) and getNamefromUID( ) functions can be called without any parameter mapping, as denoted by the keyword "DIRECT". The testUID( ) function cannot be mapped directly; however, a short procedure may be written to map this to some other call. This short procedure is identified by the procedure name mapTestUIDProc. This procedure may perform any tasks necessary to reformat the call to support a prior version, such as calling a substitute procedure, setting defaults, adding or removing parameters, etc. For example, the getNamefromUID( ) routine could instead be called to test if a UID exists. However, since such a procedure would be specific to the particular remote procedure involved, it is not discussed separately herein.
It will be appreciated that various alternative mappings, which perform additional or different mapping functions, may be incorporated into the extended interface within the scope of the present invention. Therefore, the invention should not be limited to the particular mappings and keywords utilized in the preferred embodiments disclosed herein.
To implement version mapping in an RPC application, the client-side request handling, performed in the client stub, must be modified from conventional runtime routines. In particular, request handling requires that (1) the version of the server be determined, and (2) any mapping to earlier versions be performed, prior to issuing the remote procedure call over the network.
In general there are three primary ways that a client can locate a server on a network. First, the client can explicitly be told the name and/or address of the server (e.g., via a parameter to the procedure, an environment variable, or an external configuration file). Second, the client and server can locate each other via some broadcast mechanism (e.g., the IPX SAP broadcasts). This can happen in either direction, with the client or server broadcasting its existence, and the other responding. Third, the client can look up the server in some form of network directory (e.g., the DCE cell directory service). Typically, with the first two ways, the client has very little knowledge about the server, other than its name and address. With the third way, however, the client can generally obtain additional information from the server, such as exactly what interfaces and protocols it supports.
The manner in which requests are handled during RPC runtime may be different for systems that support a network directory as opposed to those that do not. This is because version mapping needs to be determined prior to conversion of the parameters and marshalling of data in preparation for sending an RPC request over a network. If a directory exists, the client can typically determine the version of the server rather easily. However, if no directory exists, the data may be marshalled and the call made before determining that the wrong version of the server was found. This typically requires the data to be remarshalled and the call reissued.
FIG. 5 shows a flow chart of a preferred request handler, routine HANDLE REQUEST 100, for use on distributed computer systems which utilize network directories. This routine represents typical runtime processing of a remote procedure request in client stub file 34 of process 30. Routine 100 can generally be segregated into a mapper with a mapping function (blocks 102-108 and 120) and a requester with a requesting function (blocks 110-114).
As for the mapping function, routine 100 begins in block 102 by attempting to locate the destination server, typically by accessing a network directory in a manner known in the art. If the destination server is not found, the remote procedure call fails, and control passes to block 116 to indicate the failure prior to returning to the main code, or calling routine. If, however, the server is found, the version of the server is determined in block 104, again by accessing the network directory. Next, in block 106, routine 100 determines whether version mapping is required, generally by comparing the version of the server with the version of the client upon which the routine is running.
If no mapping is required, which typically occurs when the server supports the version of the client, control passes to the requesting function of routine 100, specifically to block 110 to "marshall" the request. In marshalling the request, the pertinent information required to issue the remote procedure request is gathered and formatted into a stream of bytes that can be transmitted across the network. Then, in block 112, the marshalled request data is sent to the server across the network, and the routine waits until a response is received. Next, in block 114, the response is "unmarshalled", which is essentially the reverse of marshalling, to obtain the resulting information forwarded from the server in response to the remote producer request. Once the response has been unmarshalled, the routine terminates to allow the main code to process the response.
The response from a remote procedure may consist only of an acknowledgment of the request, or may include data which was requested during the remote procedure. The operations of marshalling, unmarshalling, sending and receiving data across a network in a distributed computer system are generally understood in the art. Moreover, it will be appreciated that additional formatting or other transformation of data either in the request or in the response may be required such that both client and server obtain data from the other in a compatible format.
Returning to block 106, if it is determined that version mapping is required, e.g., because the, server does not support the version of the client issuing the remote procedure request, control passes to block 108 to determine if version mapping is possible. In this block, the version of the server is compared against the different versions to which version mapping is defined in the remote procedure interface for the client. For example, some interfaces may be made backward-compatible only for a few prior versions, e.g., if the changes between the current version and a much earlier version have become so significant that the functionality of the much earlier version is insufficient for clients running the current version. In such a case, mapping an interface to the much earlier version is unnecessary. Therefore, control is diverted in this situation to block 116 to indicate a failed call prior to returning to the main code.
If, on the other hand, the version of the server is supported by the client, control passes to block 120 to call a separate MAP REQUEST routine 120 which handles the mapping prior to the executing the requesting function of blocks 110, 112 and 114.
FIG. 6 illustrates MAP REQUEST routine 120 in greater detail. Essentially, this routine first performs a keyword determining function in block 121 by accessing the versionmap( ) parameter in the client interface (specifically in the version map or table in the client stub file) for the particular procedure defined in the remote procedure interface.
Based upon the keyword returned from the version map for the particular version of the server, blocks 122, 126, 130 and 134 divert control to separately handle the different mappings. Alternatively, blocks 122, 126, 130 and 134 may be replaced with a single "case" function as is generally known in the art.
If the version map for the particular routine and version of the server points to a user-defined procedure (e.g., the version 1.0 mapping for Routine A in FIG. 2, or the mapping for the testUID( ) routine of FIG. 4), control is passed to block 124 to call the specific procedure referred to in the version map, prior to terminating the HANDLE REQUEST routine 100. It will be appreciated that in many instances an alternative remote procedure may be called, in which case the HANDLE REQUEST routine 100 may be called recursively by this user-defined procedure.
If, on the other hand, the version map returns a "BYNAME" keyword, control is passed to block 128 by block 126 to map the various parameters to the format expected by the server. This essentially results in the original parameters for the remote procedure request being replaced with the new parameters that are specific to the server version. In addition, if a field in the new format (corresponding to the server version) does not have a counterpart in the client version of the interface, this field or parameter will default to zero. After completion of the field mapping, control then returns to the HANDLE REQUEST routine to continue processing of the request in block 110 of FIG. 5.
If the version map returns a keyword of "NOMAP", block 130 passes control to block 132 to indicate a failed call, prior to terminating the HANDLE REQUEST routine and returning to the main code. This is indicative of a procedure which does not have a counterpart on the server version, and which therefore may not be called by the client.
Finally, if the keyword return from the version map is "DIRECT", block 134 merely returns control to the HANDLE REQUEST routine (specifically block 110 of FIG. 5) to continue processing of the request. When such a keyword is encountered, no mapping is required, and the request may be made with no modification to accommodate the earlier server version.
If block 134 does not receive a "DIRECT" keyword, the system has received a keyword which is not recognized. Accordingly, control passes to block 132 to indicate a failed call prior to returning control to the main code.
In the situation where a network directory is not available in the distributed computer system, an alternative HANDLE REQUEST routine 150, also including a mapper with a mapping function (blocks 120 and 152-156) and a requester with a first requesting function (blocks 158-164), is executed as shown in FIG. 7. In this routine, the client computer process preferably supports a "cache" or table of servers and their versions so that at most one incorrect version call is made to a given server before the correct server version is found. In essence, the client computer process builds a local directory of servers and their supported versions, rather than relying on a separate network directory to provide this information.
As shown in FIG. 7, routine 150 begins with a mapping function at block 152 by checking the server version cache internal to the client. Block 154 then determines if version mapping is required. If the server is found in the cache and it is determined that the version supported by the server requires mapping from the client version, control passes to block 156 to determine if the server version is supported by the client. If the mapping is not supported, control passes to block 160 to indicate a failed call prior to returning control to the main code.
On the other hand, if the server version is supported by the client, control passes to block 120 to call the MAP REQUEST routine illustrated in FIG. 6. Then, after the request has been mapped in block 120, control passes to the first requesting function of routine 150, where block 158 marshalls the request. Block 162 then sends the marshalled request to the server and waits to receive a response thereto. The response is then unmarshalled in block 164.
Next, block 166 determines whether the server supports the client version of the RPC interface. Generally, block 166 will indicate that the server supports the client version if a suitable or expected response is returned from the server in reply to the remote procedure request.
On the other hand, if the server does not support the client version, the response to the request which is returned by the server will generally indicate a failed request, and preferably include an indication of the current version of the server (e.g., through returning a list of supported versions for the server). On the other hand, if no indication of the versions supported by the server is provided, the client may try all of its supported versions until a suitable response is received from the server, although such an implementation would not be as efficient as others.
In the case that the server doesn't support the client version, a separate routine, RESEND REQUEST routine 170, is called by block 166 prior to returning control to the main code and terminating the HANDLE REQUEST routine. Routine 170 forms a second request function for the requester of routine 150.
The RESEND REQUEST routine 170 is illustrated in greater detail in FIG. 8. First in this routine, block 172 adds the server to the version cache, as well as the supported version or versions supported by the server. In some instances, e.g., if the server has been upgraded since the last access by this client, the server may already be present in the cache, whereby only an update of the supported versions for the server is required.
Next, in block 174, the supported versions of the server are compared with the version of the client to determine whether it is possible to map the request to a version supported by the server. If this is not possible, control is diverted to block 176 to indicate a failed call and to return control to the HANDLE REQUEST routine. If, however, a version of the server is supported by the client, control passes to block 120 to map the request consistent with the version map of the client. Next, in blocks 178, 180 and 182, the request is marshalled and sent to the server, and a response is received and unmarshalled, in the manner described above. Upon completion of block 182, the routine terminates and returns to HANDLE REQUEST routine 150.
Returning to block 154 of FIG. 7, in the event that a server is not recognized in the server cache for the client, block 154 diverts control to block 158 without attempting to map the request to a prior version. Then, blocks 158, 162 and 164 are executed as described above to attempt to issue the request. In this case, the routine does not know which versions are supported by the server. Thus, this initial request serves merely the function of obtaining the supported versions of the server so that the request may be resent in a proper manner (and so that the server version cache can be updated) in RESEND REQUEST routine 170.
Various changes and modifications may be made to the preferred embodiments without departing from the spirit and scope of the invention. For example, as discussed above, different manners of detecting and maintaining a register of servers and supported versions may be used. Moreover, various degrees of mapping between versions may be supported above and beyond the keywords supported by the preferred embodiment. Other modifications will be apparent to one skilled in the art.
Therefore, the invention provides substantial benefits by virtue of the flexible and reliable manner in which multiple versions of remote procedure interfaces are permitted to coexist in a distributed computer system. As one skilled in the art will appreciate that other modifications may be made to the preferred embodiments consistent with the invention, the invention therefore lies in the claims hereinafter appended.
|Cited Patent
|Filing date
|Publication date
|Feb 13, 1987
|Dec 12, 1989
|International Business Machines Corporation
|System and method for accessing remote files in a distributed networking environment
|Feb 13, 1987
|Jan 30, 1990
|International Business Machines Corporation
|System and method for using cached data at a local node after re-opening a file at a remote node in a distributed networking environment
|Apr 21, 1992
|Feb 16, 1993
|Digital Equipment Corporation
|Server impersonation of client processes in an object based computer operating system
|Dec 17, 1990
|Apr 13, 1993
|International Business Machines Corporation
|System for file and record locking between nodes in a distributed data processing environment maintaining one copy of each file lock
|Feb 4, 1992
|Sep 21, 1993
|Digital Equipment Corporation
|RPC based computer system using transparent callback and associated method
|Nov 27, 1992
|Sep 28, 1993
|Digital Equipment Corporation
|Computer network providing transparent operation on a compute server and associated method
|Mar 29, 1990
|Nov 23, 1993
|At&T Bell Laboratories
|Apparatus and methods for performing an application-defined operation on data as part of a system-defined operation on the data
|Dec 31, 1991
|Feb 15, 1994
|Silicon Graphics, Inc.
|File alteration monitor for computer operating and file management system
|Aug 28, 1992
|Apr 26, 1994
|Tandem Computers, Inc.
|Method and system for implementing remote procedure calls in a distributed computer system
|Jan 29, 1993
|Jun 14, 1994
|Digital Equipment Corporation
|System for determining the rights of object access for a server process by combining them with the rights of the client process
|Oct 30, 1992
|Jul 12, 1994
|Software Ag
|Cooperative processing interface and communication broker for heterogeneous computing environments
|Nov 10, 1993
|Apr 4, 1995
|Digital Equipment Corporation
|Method of managing requests in a transaction processing system
|Sep 25, 1992
|Mar 5, 1996
|Bull Hn Information Systems Inc.
|Ally mechanism for interconnecting non-distributed computing environment (DCE) and DCE systems to operate in a network system
|Title not available
|Title not available
|Title not available
|Betz, Mark, "Interoperable objects: laying the foundation for distributed-object computing," Dr. Dobb's Journal, v19, n11, p. 18(13), Oct. 1994.
|H. Higaki, "Group Communications Algorithm for Dynamically Updating in Distributed Systems", IEICE Trans. Inf. Syst. (Japan), vol. E78-D, No. 4, pp. 444-454, Apr. 1995 (abstract).*
|Huang et al., "Designing an Agent Synthesis System for Cross-RPC Communication", IEEE Transactions on Software Engineering, vol. 20, No. 3, pp. 188-198, Mar. 1994.*
|Citing Patent
|Filing date
|Publication date
|Jan 4, 2002
|Jan 27, 2004
|Sony Corporation
|Method and apparatus for determining compatibility of computer programs
|May 3, 2000
|Mar 15, 2005
|Fujitsu Limited
|Distributed-object development system and computer-readable recording medium recorded with program for making computer execute distributed-object development
|Apr 23, 1999
|Jul 19, 2005
|Oracle International Corporation
|Communication architecture for distributed computing environment
|Nov 19, 2001
|Dec 13, 2005
|Lsi Logic Corporation
|Mechanism for encoding and decoding upgradeable RPC/XDR structures
|Jun 5, 2001
|May 9, 2006
|Hitachi, Ltd.
|System and method to dynamically select and locate server objects based on version information of the server objects
|May 10, 2002
|Aug 29, 2006
|Oracle International Corp.
|System and method for auto-evolvable remote procedure call structures
|Sep 2, 2005
|Oct 10, 2006
|The Regents Of The University Of California
|Edge router for optical label switched network
|Dec 4, 2000
|Dec 26, 2006
|Fujitsu Limited
|Information processing system enabling dynamically loading or replacing program component in memory allocated to activated process
|Jan 31, 2001
|Jan 30, 2007
|Hewlett-Packard Development Company, L.P.
|Extending a standard-based remote file access protocol and maintaining compatibility with a standard protocol stack
|Aug 28, 2002
|Jul 17, 2007
|Telefonaktiebolaget Lm Ericsson (Publ)
|Migration support mechanism in open service and open mobile architecture
|Jun 9, 2003
|Jun 10, 2008
|International Business Machines Corporation
|Maintaining multiple valid concurrent serialized object versions
|Jun 24, 2004
|Jun 10, 2008
|Sap Ag
|System and method for processing remote function calls
|Feb 25, 2005
|Mar 17, 2009
|Microsoft Corporation
|Common, multi-version interface that allows a distributed sybsystem to communicate with multiple versions of the distributed subsystem
|Aug 12, 2003
|Jun 23, 2009
|International Business Machines Corporation
|System and method to refresh proxy cache server objects
|Oct 28, 2004
|Dec 1, 2009
|International Business Machines Corporation
|Change management of interfaces in distributed computer systems
|Aug 25, 2005
|Jul 27, 2010
|Microsoft Corporation
|Platform management techniques of handling providers
|Jan 28, 2003
|Aug 31, 2010
|Method for downloading data to gaming devices
|Mar 11, 2002
|Oct 19, 2010
|Rexroth Indramat Gmbh
|Method for the remote control programming of machine controllers and machine controller for carrying out said method
|Jan 11, 2006
|Nov 23, 2010
|Ianywhere Solutions, Inc.
|System, method, and computer program product for executing scripts on mobile devices
|Mar 29, 2008
|Nov 30, 2010
|International Business Machines Corporation
|Maintaining multiple valid concurrent serialized object versions
|May 23, 2005
|Dec 28, 2010
|International Business Machines Corporation
|Data migration between versions of software
|Dec 18, 2006
|Jan 11, 2011
|Emc Corporation
|Interface plugin
|Oct 12, 2005
|May 31, 2011
|Method for downloading data to gaming devices
|Oct 4, 2005
|May 31, 2011
|International Business Machines Corporation
|Support for multiple interface versions
|Nov 6, 2000
|Jul 26, 2011
|Ianywhere Solutions, Inc.
|System, method, and computer program product for a scalable, configurable, client/server, cross-platform browser for mobile devices
|Feb 21, 2006
|Dec 20, 2011
|Microsoft Corporation
|Routing calls via reflective interfaces and a proxy
|Jan 19, 2007
|Jul 3, 2012
|Alcatel Lucent
|Network service version management
|Jul 6, 2005
|Jul 23, 2013
|International Business Machines Corporation
|System, method and program product for invoking a remote method
|Nov 6, 2000
|Nov 26, 2013
|Ianywhere Solutions, Inc.
|System, method, and computer program product for server side processing in a mobile device environment
|Dec 5, 2005
|Dec 10, 2013
|International Business Machines Corporation
|SCORM manifest reconciliation
|Nov 25, 2013
|Sep 27, 2016
|Ianywhere Solutions, Inc.
|System, method, and computer program product for server side processing in a mobile device environment
|Dec 4, 2000
|Dec 13, 2001
|Fujitsu Limited
|Information processing system enabling dynamically loading or replacing program component in memory allocated to activated process
|Jun 5, 2001
|Apr 25, 2002
|Toshio Yamaguchi
|Distributed object management method, implementation system and recording medium for recording the processing program for the method
|Jan 31, 2001
|Aug 1, 2002
|Christos Karamanolis
|Extending a standard-based remote file access protocol and maintaining compatibility with a standard protocol stack
|Aug 28, 2002
|Mar 27, 2003
|Ard-Jan Moerdijk
|Migration support mechanism in open service and open mobile architecture
|Nov 19, 2001
|May 22, 2003
|Delaney William P.
|Mechanism for encoding and decoding upgradeable RPC/XDR structures
|Jan 23, 2002
|Aug 7, 2003
|Vedvyas Shanbhogue
|Portable software for rolling upgrades
|Jan 28, 2003
|Dec 11, 2003
|Method for downloading data to gaming devices
|Aug 12, 2003
|Apr 8, 2004
|International Business Machines Corporation
|System and method to refresh proxy cache server objects
|Mar 11, 2002
|May 6, 2004
|Clemens Atzmueller
|Method for the remote control programming of machine controllers and machine controller for carrying out said method
|Jun 9, 2003
|Dec 9, 2004
|International Business Machines Corporation
|Maintaining multiple valid concurrent serialized object versions
|Oct 28, 2004
|Jun 30, 2005
|Banks Timothy W.
|Method and system for change management of interfaces in distributed computer systems
|Sep 2, 2005
|Jan 12, 2006
|Fei Xue
|Edge router for optical label switched network
|Jun 24, 2004
|Feb 16, 2006
|Synovic Michael J
|System and method for processing remote function calls
|Oct 12, 2005
|Feb 23, 2006
|Method for downloading data to gaming devices
|Oct 4, 2005
|Apr 13, 2006
|John Colgrave
|Support for multiple interface versions
|Feb 25, 2005
|Aug 31, 2006
|Microsoft Corporation
|Multiple version interface
|May 23, 2005
|Nov 23, 2006
|International Business Machines Corporation
|Method and system for data migration between versions of software
|Jul 6, 2005
|Jan 11, 2007
|International Business Machines Corporation
|System, method and program product for invoking a remote method
|Aug 25, 2005
|Mar 1, 2007
|Microsoft Corporation
|Platform management techniques of handling providers
|Dec 5, 2005
|Jun 21, 2007
|Butler Jason M
|SCORM manifest reconciliation
|Feb 21, 2006
|Sep 6, 2007
|Microsoft Corporation
|Routing calls via reflective interfaces and a proxy
|Oct 29, 2007
|Jun 12, 2008
|Karlheinz Dorn
|Flexible interconnection system
|Mar 29, 2008
|Jul 24, 2008
|International Business Machines Corporation
|Maintaining Multiple Valid Concurrent Serialized Object Versions
|Jan 19, 2007
|Jul 24, 2008
|Alcatel Lucent
|Network service version management
|Aug 30, 2007
|Mar 5, 2009
|Thomas Mitchell Elord
|Versioning compatibility
|Aug 30, 2007
|Mar 5, 2009
|Thomas Mitchell Elrod
|SSL socket builder
|Mar 23, 2010
|Sep 29, 2011
|International Business Machines Corporation
|Migrating electronic document version contents and version metadata as a collection with a single operation
|Nov 8, 2004
|Aug 5, 2009
|Method and system for change management of interfaces in distributed computer systems
|U.S. Classification
|709/330, 717/170
|International Classification
|Cooperative Classification
|European Classification
|Jan 9, 2006
|Fee payment
Year of fee payment: 4
|Jul 19, 2010
|Maintenance fee reminder mailed
|Dec 10, 2010
|Lapse for failure to pay maintenance fees
|Feb 1, 2011
|Expired due to failure to pay maintenance fee
Effective date: 20101210


text:
Sell your unwanted fishing items or trade them for better stuff!
G.Loomis rods for sale
Put items other than fishing for sale here.
Nice golf cart for sale, many...
Come on you Guides. Post up your locations, rates and open dates.
Cedar Creek spring time blue...
Bait and Tackle
Lure Sale
Add your favorite marina, camp ground etc.
anyone have a leaking roof ??


text:
Mortal Kombat DLC Inbound
The first DLC for Mortal Kombat is on its way. Ed Boon has recently announced that the first pack would include all seven costumes from the likes of Scorpion, Sub-zero, Reptile, Ermac, Jade, Mileena, and Kitana, as well as the classic fatalities for Scorpion, Sub-Zero, and Reptile. The single piece of downloadable content will be bundled for release shortly, although no official price has been announced.
[blackbirdpie url="https://twitter.com/#%21/noobde/status/73447795331305473″]
There's still more Mortal Kombat DLC on the horizon after this first pack is released. The much talked about Kenshi and Skarlet characters are definitely still in the works with a playable version of Skarlet at the NetherRealm E3 Booth. Look for the content on Xbox Live shortly, and on PSN just as soon as the PlayStation Store gets up and running.


text:
We recommend upgrading to the latest Internet Explorer, Google Chrome, or Firefox.
If you are using IE 9 or later, make sure you turn off "Compatibility View".
Handpicked brands for you
Our mini shop at the #beyondthesurfacefilm Germany premiere in support of the girls in #SISP who participated in one #beyondproject last year in which we made jewelry together out of sea shells and sea glass! Danke! #kovalamsurfclub #ingromswetrust


text:
A huge fire engulfed a Russian nuclear submarine as it was being repaired Thursday, sending flames and smoke billowing into the sky, but officials said all weapons had been removed and there was no radiation risk.
Firefighters launched a massive operation to douse the flames after the blaze broke out on the 11,740-tonne Yekaterinburg while it was docked in the the northern Murmansk region near Russia's border with Norway.
The fire was eventually put out about five hours after it first started in the Roslyakovo dockyard near one of Russia's main naval bases, defence ministry spokesman Igor Konashenkov said, quoted by the Ria Novosti news agency.
"In order to prevent a new fire breaking out, the submarine will be lowered into the water before returning to its original position," he added.
The vessel had all its nuclear missiles and conventional rockets removed before entering the dock, Konashenkov had told state television earlier, adding that its two reactors had been switched off well in advance and there was "no threat of a nuclear radiation leak".
"The power unit was switched off and is now safe," he told state television.
It is not yet known how the fire started, but a spokesman for the Russian military prosecutor, quoted by Ria Novosti, said a criminal probe had been launched into the "reckless destruction or damage of military assets".
The fire broke out on wooden scaffolding surrounding the submarine and spread to its outer hull, Northern Fleet navy spokesman Vadim Serga told the Interfax news agency.
"There is no threat to the onboard equipment," he added.
Eleven fire brigades and a navy fire boat were involved in the salvage operation, but television footage showed huge clouds off smoke billowing from the shipyard even after the flames had been contained.
A special helicopter also doused the flames with tonnes of water from above, the Murmansk region's TV-21 channel reported.
"I would say the flames reached about 10 metres (over 30 feet)," one unnamed witness told the station.
The Delta IV class vessel was commissioned by the former Soviet Union in 1985 and can carry up to 16 inter-continental ballistic missiles, according to Russian press descriptions of the submarine.
Russia is believed to have six Delta IV submarines, which form the backbone of its sea-based nuclear defences.
The worst disaster to befall the Northern Fleet in recent years was the sinking of the Kursk nuclear submarine in August 2000, which killed all 118 seamen aboard when it caught fire and exploded in the Barents Sea.
Thursday's fire occurred near the closed town of Severomorsk, one of the Russian navy's main bases.
In a separate incident involving the military Thursday, an Sukhoi 24 fighter jet crashed on landing in the southern region of Volgograd, although both pilots managed to eject and were unharmed, the defence ministry said.
"The plane exploded during landing," said a ministry spokesman quoted by Interfax. "The crew ejected following orders."
The accident occurred at the end of a routine training flight at the Marinovka aerodrome, 60 kilometres (40 miles) from the city of Volgograd.
Accidents involving military aircraft are fairly frequent in Russia.


text:
Mr. 4,000: Ichiro reaches career milestone with classic base hit
Ichiro Suzuki joined elite company on Wednesday, joining Pete Rose and Ty Cobb as the only professional baseball players to collect 4,000 hits at the major league level. Of those 4,000 hits, 2,722 have now come in Major League Baseball (Rose and Cobb's hit total are both exclusive to MLB), which ironically moved him past New York Yankees legend Lou Gehrig on the all-time hit list. The first 1,278 hits of Ichiro's all came while playing in Japan's equivalent of MLB.
Fittingly enough, No. 4,000 was an Ichiro special — a slap single just past a diving Brett Lawrie at third base. The clean hit came against knuckleballer R.A. Dickey, whom Ichiro had been 0 for 10 against lifetime.
After reaching first base, Ichiro's teammates all flooded out of the dugout to congratulate him on his milestone. An emotional Munenori Kawasaki — Toronto's starting second baseman on Wednesday and another of MLB's Japanese stars — was shown applauding several times as Ichiro tipped his cap and acknowledged the crowd's standing ovation.
It was a special moment for a very special player. Though as Yahoo!'s Jeff Passan wrote recently, when the dust settles for Ichiro, he'll simply view it as another gift rather than a round number or a milestone.
For those who enjoy the numbers, though, here's a pretty cool breakdown courtesy of ESPN's Buster Olney and The Pinstriped Bible on Twitter.
MLB hits ages 27-39: Ichiro 2,722. Pete Rose 2,658. Ty Cobb 2,300. Derek Jeter 2,300. Stan Musial 2,229. Hank Aaron 2,200.
— Buster Olney (@Buster_ESPN) August 21, 2013
That really puts Ichiro's production into perspective.
Ichiro hit breakdown: 3106 singles, 552 doubles, 116 triples, and 226 homers. 1278 with Orix, 2533 with Seattle, and 189 with the Yanks.
— The Pinstriped Bible (@pinstripebible) August 21, 2013
Obviously the bulk of Ichiro's production came during his time in Seattle, so the night wouldn't have been complete without the Mariners acknowledging his big moment.
Another milestone on his road to Cooperstown. Congrats, Ichiro! pic.twitter.com/yitzP5yjIz
— Seattle Mariners (@Mariners) August 21, 2013
Well played, Seattle. And congratulations, Ichiro.
Looking for more baseball chatter?
Follow @bigleaguestew, @Townie813, @AnswerDave and @MikeOz on Twitter
Also, check out the BLS Facebook Page


text:
If there's one thing Modern Family star Ariel Winter is not, that's being shy. The 19-year-old actress is known for frequently sharing raunchy pictures that leave little to the imagination, and although such posts have been called 'slut photos' by some, Winter has always seemed quite unfazed by such comments.
Attending the Smurfs: The Hidden Village premiere on the 7th of April, the California native was not afraid to show much of her body, wearing a provocative dress with transparent sides
Some Instagram users liked neither her clothes nor her behavior, as the 19-year-old posted a picture of her flirting with a Smurf mascot
"Even in front of kids you are showing too much SKIN!" a certain Chloe Davies wrote
Winter has countered with a #SpeakBeautiful hashtag, saying that "those who attack me with body-shaming comments, your words are a reflection of what's inside of you, not me"
Winter was criticized this year when she wore a glitzy number with pointed gold stilettos and bronzy eye makeup at a Modern Family screening, while the rest of the cast wore jeans and weekend shirts
The actress wondered why anyone would care and remained determined not to be "stifled" in her fashion choices
The Los Angeles-born wore a daring bodycon dress for the Delta Airlines pre-Grammy party
On the 10th of May, it was announced that Modern Family has been renewed for a ninth and tenth season
The mockumentary sitcom, which premiered back in 2009, has won numerous accolades, although it has faced criticism as well during its latter seasons
Another Instagram post, captioned "The booty's back in Cali" has also raised significant controversy and gathered more than 2,000 comments