Generating and caching software code.

(21) Application number: 2014009761 (51) Int. Cl: G06F 9/06 ^{(2006 0η}

G06F9 / 44 (²⁰⁰⁶·⁰¹>

G06F9 / 30 (²⁰⁰⁶⁰¹>

(86) PCT application number: US 13/24559 (87) PCT publication number: WO 2013/122758 (08/22/2013) (30) Priority (s): 02/13/2012 US 13 / 371,479 (71 ) Applicant:

MICROSOFT CORPORATION

One Microsoft Way 98052-6399 Redmond Washington US (72) Inventor (s):

Steven Edward LUCCO c / o Microsoft Corporation, LCA - International Patents One Microsoft Way Redmond Washington 98052-6399 US

Jomo FISHER Michael Wayne JACKSON Yunus KILIC

Jesse D. MCGATHA Jedrzej Z. MIADOWICZ Steven J. STEINER (74) Representative:

César RAMOS DE MIGUEL

Pedro Luis Ogazón 17 ALVARO OBREGON Distrito Federal 01000 MX (54) Title: GENERATION AND SAVED IN MEMORY CACHE OF SOFTWARE CODE. (54) Title: GENERATING AND CACHING SOFTWARE CODE.

(57) Summary

Aspects of the topic described here refer to generating and caching software code. In aspects, a target device may receive software to install. The software may include source code that has not been compiled. The target device can install the software and indicate that the source code of the package is to be compiled into intermediate or executable code that is persistently stored. If the target device receives a request to run the software before it is collected, the target device can collect and run the software without delay. If the target device receives a request to run the software after it was collected, the target device can obtain and execute the collected code. The above behavior can also be applied to script code obtained from a remote server to the target device.

(57) Abstract

Aspects of the subject matter described herein relate to generating and caching software code. In aspects, a target device may receive software to install. The software may inelude source code that has not been compiled. The target device may install the software and indicate the source code of the package is to be compiled into intermediaries or executable code that is persistently stored. If the target device receives a request to execute the software prior to it being compiled, the target device may compile and execute the software without delay. If the target device receives a request to execute the software after it is compiled, the target device may obtain and execute the compiled code. The behavior above may also be applied to scripting code obtained from a server remote to the target device.

Institute

Mexican Property

Industrial

PATENT TITLE NO. 336964

I KNOW

SfcéaiTARIA PI KTOOMiA

Headlines):

Address:

Denomination:

Classification:

Inventor (s):

MICROSOFT CORPORATION

One Microsoft Way, Redmond, Washington, 98052-6399, USA

GENERATION AND SAVING IN MEMORY CACHE OF SOFTWARE CODE lnt.CI.8: G06F9 / 06; G06F9 / 30; G06F9 / 44

JOMO FISHER; MICHAEL WAYNE JACKSON; YUNUS KILIC; STEVEN EDWARD LUCCO; JESSE D. MCGATHA; JEDRZEJ Z. MIADOWICZ; STEVEN J.: INER.

<img file="MX336964B_D0001.tif" />

ey of 05/1999, action V ¡al (DOF 12/14/1999, including sections I and III and 30 of the Organic Statute and 5th paragraph a) of the Agreement that delegates powers to the Deputy General Directors, Coordinator / Divisional Directors, I ituiars of the Regional Offices, Divisional Deputy Directors, Departmental Coordinators and other subordinates of the Mexican Institute of Industrial Property. (DOF 12/15/1999, amended on 02/04/2000, 07/29/2004, 08/04/2004 and 09/13/2007).

Industrial hnpn ogables, I saw intes the

<img file="MX336964B_D0002.tif" />

Issue Date: February 8, 2016

THE DIVISIONAL DIRECTOR OF PATENTS

<img file="MX336964B_D0003.tif" />

NAHANNY CANAL REYB $

Arenal No. 550, Floor 1.

Co!. Santa María Tepepan Town Xochimilco Delegation,

CP 16020, Mexico City

Tei. (55) 53 34 07 00 www.impf.gob.mx

<img file="MX336964B_D0004.tif" />

<img file="MX336964B_D0005.tif" />

MX / 2016/10896 jWí so iv / 116 /

<img file="MX336964B_D0006.tif" />

BACKGROUND

Scripting languages ​​can be found in various environments. For example, many Internet browsers have a scripting language that allows a web page to customize its behavior based on user input or other data. Scripting languages ​​can also be found in environments outside of Internet browsers. One problem with scripting languages ​​is that they can be slow, especially at startup and possibly with every run, compared to conventional compiled programs.

The issue claimed here is not limited to modalities that solve any of the advantages or that operate only in environments such as those described above. Rather, only this background is provided to illustrate an illustrative area of ​​technology where some of the embodiments described herein may be practiced.

BRIEF DESCRIPTION OF THE INVENTION

Briefly, aspects of the topic described here refer to generating and caching software code. On

IMPI

INSTITUTO MEXICANO DE LA PROPERTY Aspects, a target device may receive software for installation. The software may include source code * l | UÉ nu lid sidu —— compiled. The target device can install the software and indicate the source code of the package to be collected into intermediate or executable code that is persistently stored.

If a target device receives a request to run the software before it is collected, the target device can collect and run the software without delay. If the target device receives a request to run the software after it was collected, the target device can obtain and execute the collected code. The above behavior can also be applied to script code obtained from a remote server to the target device.

This Brief Description is provided to briefly identify some aspects of the subject that is further described in the Detailed Description below. This Brief Description is not intended to identify key or essential characteristics of the claimed topic, nor is it intended to be used to limit the scope of the claimed topic.

The phrase "subject matter described herein" refers to the subject matter described in the Detailed Description unless the context clearly indicates otherwise. The term "aspects" should be read as "at least one aspect". Identifying Aspects of the Item Described in the Detailed Description is not intended to identify key or essential characteristics of the claimed item.

The aspects described above and other aspects of the subject described herein are illustrated by way of example and are not limited in the attached figures where like reference numerals indicate similar elements and where:

MEXICAN IMPIOINSTITUTE

OF THE PROPERTY x

INDUSTRIAL

BRIEF DESCRIPTION OF THE DRAWINGS

Figure 1 is a block diagram depicting an illustrative general-purpose and computing environment into which aspects of the subject matter described herein may be incorporated;

Figure 2 is a block diagram depicting an illustrative arrangement of system components in which aspects of the subject matter described herein may operate;

Figure 3 shows an illustrative data structure that can be used in accordance with aspects of the subject matter described herein;

Figure 4 is a block diagram depicting an illustrative arrangement of components of an environment in which aspects of the subject matter described herein may operate; Y

Figures 5-6 are flowcharts that generally represent illustrative actions that may occur in accordance with aspects of the subject matter described herein.

DETAILED DESCRIPTION

DEFINITIONS

As used herein, the term "includes" and its variants are

Λ J, ..&gt; JU - »i'A im'ctiTUTO MEXICANO '- &lt;·“ “^ 1 f · &lt;/ ^ΙΝ*^τ yac is property _ v »ft to be read as open-ended terms that mean" arT ^ ineludes, but is not limited to ". The term “or” is to be read and / or unless the context clearly indicates otherwise. The term "based on is to be read as" based at least in part on *. The terms "one mode" and "one mode" are to be read as "at least one mode". The term "other mode" is to be read as "at least one other mode".

As used herein, terms such as "a," an ", and" in "are inclusive of one or more of the indicated item or action. In particular, in the claims a reference to an article generally means that at least one such article is present and a reference to an action means that at least one instance of an action is performed.

Sometimes here the terms "first", "second," third "and so on can be used. Without additional context, the use of these terms in the claims is not intended to imply order but rather to be used for identification purposes. For example, the phrases "first version" and "second version do not necessarily mean that the first version is the first version or was created before the second version or even that the first version is requested or operated before the second version. Rather, these phrases are used to identify different versions.

The headings are for convenience only; information on a given topic can be found outside the section whose

INSTITUTO MEXICANO DE LA PROPERTY heading indicates that topic. industrial

Other definitions, explicit or implicit, may be detailed below.

ILLUSTRATIVE OPERATING ENVIRONMENT

Figure 1 illustrates an example of a suitable computer system 100 environment in which aspects of the subject matter described herein can be implemented. The computer system environment 100 is only one example of a suitable computing environment and is not intended to suggest any limitation to the scope of use or functionality of aspects of the subject matter described herein. Nor should the computing environment 100 be construed as having any dependencies or requirements that refer to any or combination of components illustrated in illustrative operating element 100.

The subject matter aspects described here are operative with numerous other general purpose or special purpose computer system configurations or environments. Examples of well-known computing systems, environments, or configurations that may be suitable for use with aspects of the subject matter described herein include personal computers, server computers, portable or laptop devices, multiprocessor systems, microcontroller-based systems, TV boxes. cable, programmable consumer electronics, network PCs, minicomputers, macrocomputers, personal digital assistants (PDAs), gaming devices, printers, gadgets

<img file="MX336964B_D0007.tif" />

INSTITUTO MEXICANO Λ £ DE LA PROPERTY V · including cable tv box, media center, or other OP ^ Vatos, '* computing devices incorporated or attached to urr auluiriOVIl, other mobile devices, distributed computing environments that include any of the prior systems or devices, and the like.

Aspects of the topic described here can be described in the general context of computer-executable instructions, such as program modules, that are executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, and so on, that perform particular tasks or implement particular abstract data types. Aspects of the topic described here can also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules can be located on both local and remote computer storage media including memory storage devices.

With reference to Figure 1, an illustrative system for implementing aspects of the subject matter described herein includes a general purpose computing device in the form of a computer 110. A computer can include any electronic device that is capable of executing an instruction. The components of the computer 110 may include a processing unit 120, a system memory 130, and a common system driver 121.

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL that couples various system components including system memory to processing unit 120. The common system driver 121 can be any of several types of common conductor structures including a common memory conductor or memory controller, a common conductor peripheral, and a local common conductor using any of a variety of common conductor architectures. By way of example, and not limitation, such architectures include an Industry Standard Architecture (ISA) common conductor, Micro Channel Architecture (MCA) common conductor, Enhanced ISA common conductor (EISA), local Video Electronics Standards Association (VESA), Peripheral Component Interconnect (PCI) common conductor also known as Mezzanlne common conductor, Common Peripheral Component Interconnect Extended (PCI-X) driver, Advanced Graphics Port (AGP), and PCI Express (PCIe).

The processing unit 120 may be connected to a hardware security device 122. The security device 122 may store and be capable of generating cryptographic keys that can be used to secure various aspects of the computer 110. In one embodiment, the security device 122 may comprise a Trusted Platform Module (TPM) chip, TPM Security Device, or the like.

Computer 110 typically includes a variety of computer-readable media. The media readable by

<img file="MX336964B_D0008.tif" />

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL

<img file="MX336964B_D0009.tif" />

Computer can be any available media that can be accessed by computer 110 and includes both volatile and non-volatile media, and removable and non-removable media. By way of example, and not limitation, computer-readable media may comprise computer storage media and communication media.

Computer storage media includes both volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information such as computer-readable instructions, data structures, program modules, or other data. Computer storage media include RAM, ROM, EEPROM, solid state storage, flash memory or other memory technology, CD-ROM, digital versatile discs (DVD) or other optical disc storage, magnetic cassettes, magnetic tape, storage magnetic disk or other magnetic storage devices, or any other medium that can be used to store the desired information and that can be accessed by computer 110.

The communication medium typically represents computer executable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any means of information delivery. The term "modulated data signal" means a signal that has one or more of its

<img file="MX336964B_D0010.tif" />

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL characteristics established or changed in such a way to encode information in the signal. By way of example, and not limitation, the communication medium includes wired media such as wired network or direct wired connection, wireless media such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above must also be included within the scope of computer-readable media.

System memory 130 includes computer storage media in the form of volatile and / or non-volatile memory such as read-only memory (ROM) 131 and random access memory (RAM) 132. A basic input / output system 133 ( BIOS), which contains the basic routines that help transfer information between elements within computer 110, such as during boot, is typically stored in ROM 131. RAM 132 typically contains data and / or program modules that are immediately accessible to and / or are currently being operated by processing unit 120. By way of example, and not limitation, Figure 1 illustrates operating system 134, programs application 135, other program modules 136, and program data 137.

Computer 110 may also include other removable / non-removable, volatile / non-volatile computer storage media. By way of example only, Figure 1 illustrates a hard drive 141 that reads from or writes to non-movable, non-volatile magnetic media, a hard drive

<img file="MX336964B_D0011.tif" />

OF THE PROPERTY V.

INDUSTRIAL magnetic 151 that reads from or writes to a removable magnetic disk,

Non-volatile GaeMMnaMMnnaMMHHBKaBWHtSQiiuiBu 152, and an optical disc drive 155 that reads from or writes to a removable, non-volatile optical disc 156 such as a CD-ROM or other optical media. Other removable / non-removable, volatile / non-volatile computer storage media that may be used in the illustrative operating environment include magnetic tape cassettes, flash memory cards and other solid state storage devices, digital versatile disks, other optical disks, digital video tape, solid state RAM, solid state ROM, and the like. Hard disk drive 141 can be connected to system common conductor 121 through interface 140, and magnetic disk drive 151 and optical disk drive 155 can be connected to system common conductor 121 through interface for non-volatile memory. removable such as interface 150.

The drives and their associated computer storage media, discussed above and illustrated in Figure 1, provide storage of computer-readable instructions, data structures, program modules, and other data for the computer 110. In Figure 1, by For example, hard disk drive 141 is illustrated as storing operating system 144, application programs 145, other program modules 146, and program data 147. Note that these components may be the same or different from operating system 134, application programs 135, other program modules 136, and

<img file="MX336964B_D0012.tif" />

program data 137. Operating system 144, application programs 145, other program modules 146, and program data 147 are provided here with different numbers to illustrate that they are, at a minimum, different copies.

A user can enter commands and information into computer 110 through input devices such as a keyboard 162 and pointing device 161, commonly referred to as a mouse, trackball, or touch pad. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, a touch screen, a writing tablet with a gesture capture device, or the like. These and other input devices are frequently connected to the processing unit 120 through a user input interface 160 that is coupled to the system common conductor, but may be connected through other interface and common conductor structures, such as a parallel port, game port, or universal serial common driver (USB).

A monitor 191 or other type of display device is also connected to the common system conductor 121 through the interface, such as a video interface 190. In addition to the monitor, computers can also include other peripheral output devices such as speakers 197 and printers 196, which can be connected through the peripheral output interface 195.

Computer 110 can operate in a network environment

<img file="MX336964B_D0013.tif" />

IMPI

MEXICAN INSTITUTE

OF THE PROPERTY

INDUSTRIAL using logical connections to one or more remote computers, such as remote computer 180. Remote computer 180 can be a personal computer, server, router, network PC, peer device, or other common network node, and typically includes many or all of the items described above in relation to computer 110, although only one memory storage device 181 is illustrated in Figure 1. The logical connections illustrated in Figure 1 include a local area network (LAN) 171 and a wide area network (WAN) 173, but may also include other networks. Such network environments are commonly located in offices, extended enterprise computer networks, intranets, and the Internet.

When used in a LAN environment, computer 110 is connected to LAN 171 through a network interface or adapter 170. When used in a WAN environment, computer 110 may include a 172 or other modem. means for establishing communications over the WAN 1 73, such as the Internet. Modem 172, which may be internal or external, may be connected to system common conductor 121 through user input interface 160 or other appropriate mechanism. In a network environment, the illustrated program modules relating to computer 110, or portions thereof, may be stored on the remote memory storage device. By way of example, and not limitation, Figure 1 illustrates remote application programs 185 as resident in memory device 181. It will be appreciated that

IMPIOUS

MEXICAN INSTITUTE OF INDUSTRIAL PROPERTY

<img file="MX336964B_D0014.tif" />

the network connections shown are illustrative and other means may be used to establish a communication link between the computers.

Generation and Saving in Code Cache Memory

As mentioned previously, compared to a conventional program that has been compiled, a scripting language can seem slower to a user, especially on initial startup.

Figure 2 is a block diagram depicting an illustrative arrangement of system components in which aspects of the subject matter described herein may operate. The components illustrated in Figure 2 are illustrative and are not intended to be all inclusive of components that may be required or included. In other embodiments, the components and / or functions described in conjunction with Figure 2 may be included in other components (shown or not shown) or placed in sub-components without departing from the spirit or scope of aspects of the subject matter described herein. In some embodiments, the components and / or functions described in conjunction with Figure 2 can be distributed across multiple devices.

Turning to Figure 2, system 205 can include script components 210, storage 220, communication mechanism 225, and other components (not shown). System 205 may comprise one or more computing devices.

MEXICAN INSTITUTE ^W OF THE? R °^PlE?TO?

INDUSTRY!"

Such devices may include, for example, personal computers, server computers, mobile or laptop devices, multiprocessor systems, microcontroller-based systems, cable TV box, programmable consumer electronics, network PCs, minicomputers, macrocomputers, cell phones, etc. personal digital assistants (PDAs), gaming devices, printers, gadgets including cable tv box, media center, and other gadgets, computing devices incorporated or attached to a car, other mobile devices, distributed computing environments including any of the above systems or devices, and the like.

Wherein the system 205 comprises a single device, an illustrative device that may be configured to act as the system 205 comprises the computer 110 of Figure 1. Where the system 205 comprises multiple devices, each of the multiple devices may comprise one Similar or differently configured computer 110 of Figure 1.

The script components 210 may include an installer 215, a code generator 216, a cache manager 217, an execution manager 218, and other components (not shown). As used herein, the term components is to be read to include all or a portion of a device, a collection of one or more software modules or portions thereof, some combination of one or more software modules, or portions of the same and one or more devices and portions of the

<img file="MX336964B_D0015.tif" />

IMPI

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL

<img file="MX336964B_D0016.tif" />

themselves, and the like.

Communications mechanism 225 allows system 205 to communicate with other entities. For example, communication mechanism 225 may allow system 205 to communicate with other entities to obtain packets and / or script code that can be cached in system 205. The communications mechanism 255 may be a network interface or adapter 170, modem 172, or any other mechanism for establishing communications as described in conjunction with Figure 1.

Storage 220 is any storage medium capable of providing access to data. Access as used herein can include read data, write data, delete data, update data, a combination including two or more of the above, and the like. The storage may include volatile memory (eg, RAM, an in-memory cache, or the like) and non-volatile memory (eg, persistent storage).

The term data is to be read broadly to include anything that can be represented by one or more computer storage elements. Logically, the data can be represented as a series of 1's and 0's in volatile and non-volatile memory. In computers that have a non-binary storage medium, data can be represented according to the capabilities of the storage medium. Can be organized

<img file="MX336964B_D0017.tif" />

data in different types of data structures including simple data types such as numbers, letters, and the like, hierarchical, linked, or other related data types, data structures that include multiple different data structures or simple data types, and Similar. Some examples of data include information, program code, program status, program data, other data, and the like.

Storage 220 can comprise hard disk storage, other non-volatile storage, volatile memory such as RAM, other storage, some combination of the above, and the like and can be distributed across multiple devices. Storage 220 can be external, internal, or include components that are both Internal and external to the system.

205.

To decrease startup and execution times, reduce memory space, to allow protection against forgery, and for other reasons, the code generator 216 may compile source code into byte code or some other intermediate code or executable code. The code includes instructions that indicate actions that a computer will take. The code can also include data, resources, variables, definitions, relationships, associations, and the like that include information other than actions that the computer will take. For example, the code can include images, web pages, HTML, XML, other content, and the like. In one embodiment, your code can include a

IMPI

MEXICAN INSTITUTE OF INDUSTRIAL PROPERTY

<img file="MX336964B_D0018.tif" />

software project. The software may include or refer to one or more pieces of code, data, resources, variables, definitions, relationships, associations, and the like that include information other than actions to be taken by the computer, configuration information, and the like.

Actions indicated by code can be coded in a source code language that includes scripted and unscripted languages, intermediate language, assembly language, binary code, another language, some combination of the above, and the like.

Installer 215 can install packages on system 205. A package can include one or more software applications. Installer 215 may include a deployment extension handler that allows custom actions to be performed based on the installed package, the target machine on which the package is installed, whether the package includes script code, or other criteria.

In one implementation, when the installer 215 finds a package with script code there, the installer 215 can add elements corresponding to the package components to a row or other data structure to pre-collect the package code.

The code generator 216 can take elements from the data structure and can generate byte code, executable code, or some other code from the code corresponding to each of the elements. An item can include a file that

<img file="MX336964B_D0019.tif" />

includes script, a portion of a file (eg, script embedded within an HTML page), compiled code, or the like. For simplicity, the term byte code is frequently used here to denote the code that the code generator 216 generates. However, it will be understood that I Code Generator 216 is not limited to generating and caching n byte code and may, in other implementations, generate and cache other types of code including those types of code that have been mentioned previously.

In one implementation, the code generator 216 may wait until a package and elements corresponding to the package placed in the data structure for collection have been fully installed before generating byte code. In another implementation, the code generator 216 can start generating byte code as soon as an item is available in the data structure or as soon as a source code module is installed. In this other implementation, in one example, I code generator 216 can dispose of the generated byte code if the package installation fails. In another example, I code generator 216 may restart generation from the point where it left off (for example, after power is restored and the machine is restarted). In one implementation, the code generator 216 may be implemented as a procedure to perform when the system 205 is idle (for example, without installing packages or performing other tasks that consume

<img file="MX336964B_D0020.tif" />

₁₉ IMPI ¹ MEXICAN INSTITUTE

OF THE PROPERTY

INDUSTRIAL the processing bandwidth of the system 205), when the system 205 is operating on line power (for example, instead of battery power), at defined or configurable times of the day, or the like.

The term "procedure" and its variants as used herein can include one or more procedures, sequences, components, libraries, traditional objects that perform tasks, and the like. A procedure can be implemented in hardware, software, or a combination of hardware and software. In one embodiment, a procedure is any mechanism, however named, capable of using or performing an action. A procedure can be implemented in hardware, software, or a combination of hardware and software. In one embodiment, a procedure is any mechanical, however named, capable of or used in performing an action. A procedure can be distributed across multiple devices or a single device.

In one implementation, the code generator 216 can also be used to generate code on the fly (eg, as the code is found). For example, if a user installs software and wishes to run the software before the byte code is generated for the entire package that includes the software, the code generator 216 can be used to generate code for the software. In other words, the user is not required to wait for the 216 g code generator to return the byte code.

IMPI

MEXICAN INSTITUTE OF INDUSTRIAL PROPERTY

<img file="MX336964B_D0021.tif" />

for the entire package before the user is allowed to run the package software. In addition, there may be other situations in which the source code for a component has changed and where the code generator 216 can be used to generate byte code for the component on an expedited basis.

In addition, the code generator 216 can be used on demand to collect code and cache code. For example, in an Internet browser application, links to new code can be dynamically discovered. For example, the web document may include links to other code to download and run. The code generator 216 can be used to collect the code indicated by these links and cache the collected code to speed up subsequent executions of the code.

Code generator 216 may be implemented not to use a "protected area" to generate code. A protected area is an environment that has limited rights regarding data that it can access. In one implementation, the code generator 216 can be implemented as a restricted rights procedure. The procedure can be passed to a control for a byte code file that the procedure can read from and write to and can be granted read-only access to the source code. For security purposes, the procedure may not have access to resources other than those mentioned above.

<img file="MX336964B_D0022.tif" />

In one implementation, the code generator 216 can be hosted in a virtual environment. A virtual environment is an environment that is simulated or emulated by a computer. The virtual environment can simulate or emulate a physical machine, operating system, group of one or more interfaces, portions of the above, combinations of the above, or the like. When a machine is simulated or emulated, the machine is sometimes called a virtual machine. A virtual machine is a machine that, to software running in the virtual machine, appears to be a physical machine. The software can save files to a virtual storage device such as a virtual hard drive, virtual floppy disk, and the like, it can read files from a virtual CD, it can communicate through a virtual network adapter, and so on.

A virtual environment can have restricted or no access to data other than resources outside the virtual environment. As such, a virtual environment can provide a suitable environment for collecting untrusted code without worrying about whether the code will infect the host of the virtual environment.

After writing the byte code to a file, the procedure can electronically sign or otherwise "seal" the file so that any modifications to the file can be detected. File sealing can take many file and / or cryptographic system forms that will be understood by those skilled in the art. For example, in a

<img file="MX336964B_D0023.tif" />

In implementation, a file system can set an extended ___ attribute on a sealed file. If the file is modified after that, the extended attribute can be changed to indicate that the file is no longer sealed.

Writing the byte code to storage 220 is sometimes indicated here as caching the byte code. The cache manager 217 may operate to store the byte code in storage 220 and provide access to the byte code on demand. The cache manager 217 can ensure that the byt code is persistently stored in storage 220 so that the byte code is available after a restart of the system 205. The cache manager 217 can also store a copy of the byte code in main memory, high-speed cache, video memory, other memory including volatile and non-volatile memory, or the like, if desired, to speed up code access. byte.

Also, although the term file is used here sometimes, it will be understood that in other implementations the byte code may be written to volatile and / or non-volatile memory, a database, or portion thereof (for example, a register). , or some other storage without departing from the spirit or scope of aspects of the subject described here.

If more than one user installs a package, a deployment can cache multiple copies or just one copy

MEXICAN INSTITUTE OF INDUSTRIAL PROPERTY

<img file="MX336964B_D0024.tif" />

of the byte code for the packet in storage 220. Where a packet points to more than one processor architecture (for example, 32-bit and 64-bit), the code generator 216 can generate and cache byte code to point for each processor architecture.

In some implementations, there may be multiple triggers to regenerate the byte code of a packet. For example, if the seal of a file that includes the byte code has been broken (eg tampering is detected), storage media has been corrupted, or other data indicates that the cache may be invalid or not intact, this it can serve as a trigger that the packet byte code is to be regenerated. In this case, if the execution manager 218 determines that the seal has been broken, the execution manager 218 may instruct the code generator 216 to regenerate the byte code for the packet. The code generator 216 can regenerate the byte code in a way similar to how the code generator 216 first generated the byte code (for example, by placing elements corresponding to the components of a packet in a row or other data structure indicating a need to generate the byte code).

As another example, if the environment using the bytecode has been upgraded to a new version, this may trigger regeneration of the bytecode. For example, if an Internet browser or other runtime environment has been upgraded to a new

<img file="MX336964B_D0025.tif" />

MEXICAN INSTITUTE.

OF THE PROPERTY \

INDUSTRIAL version which has a different byte code syntax or grammar, this may trigger to regenerate the proper byte code for the new version. In this example, the trigger can occur when a user tries to run the software associated with the byte code. This can cause the byte code to be regenerated with use and can avoid regenerating the byte code for all installed packages at once.

As another example, if a periodic maintenance task detects that the runtime environment has been upgraded to a new version that has a different byte code syntax or grammar, this may trigger regeneration of the appropriate byte code for the new version.

As another example, if a new version of the package is to be installed, this can serve as a trigger to regenerate the byte code.

As another example, if the byte code is removed for some reason, this can serve as a trigger to regenerate the byte code.

In storage 220, the source code and corresponding 20 byte code can be stored, in one example, as illustrated in Figure 3. Figure 3 shows an illustrative data structure that can be used in accordance with aspects of the topic here. described. In one implementation, the data structure illustrated in Figure 3 may have a box indicating the source code files and byte code representations.

<img file="MX336964B_D0026.tif" />

<img file="MX336964B_D0027.tif" />

OC INSTITUTO MEXICANO «· DE LA PROPERTY

INDUSTRIAL that are available in the data structure. The table can also include data indicating that the source code files and byte code representations are located in the data structure. The data structure can be stored in or represented as a file, in a database, or in other storage without departing from the spirit and scope of aspects of the subject described here.

Turning to Figure 3, the data structure 305 can have source code and corresponding byte code placed. If the storage 220 is implemented as a file system, the data structure 305 can improve the efficiency of obtaining data as it can reduce the number of file or similar handling required to access the byte code. Where the source code resides in a package as opposed to one or more web pages or the like, placing the source code and corresponding byte code may be the default behavior. This default behavior can be overridden, if desired.

In another implementation, where storage 220 is implemented as a file system, there may be a separate byte code file for each of one or more components of a package. Although this may be less efficient in some scenarios, it may have other benefits and uses. This implementation can be used, for example, when the source code can reside externally to a package (for example, in

<img file="MX336964B_D0028.tif" />

one or more websites) and / or when the source code can be dynamically generated.

As another example, this can be used where naturally isolated experiences exist where the host or user may wish to purge all the information associated with an individual web site.

As another example, this can be used in scenarios in which a browser is pre-informed of the resources on a given website. In this example, a browser can pre-search website resources so that the website can be used even where there is no network connection. In this example, byte code can be generated even for deeper pages on the website despite not finding an explicit reference to script files for the pages in the markup of

HTML.

Determining whether to search for the corresponding source code and byte code in an individual file, or to find a separate file for each source code / byte code pair, can be based on the environment you are running from the package. If the environment is a web browser, the cache manager can look for a separate file for byte code corresponding to each source code component. If the environment is an application framework or other environment (for example, the pre-informed website example described above) where all the components of the

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL

<img file="MX336964B_D0029.tif" />

source code in advance because they come from a package, the cache manager can look up the byt code for the entire package to be put into a single file.

Not all of the source code component of a package may have corresponding byte code in the 305 data structure. For example, for various reasons it may be desirable to create the byte code for one or more components of a package. In such cases, the source code and byte code for the component (s) may be omitted from the 305 data structure.

In addition, the data structure 305 can be a memory distributed to share between two or more packages. For example, in some cases, different packages may have one or more identical font components. In these cases, memory allocation can be used to share the byte code for identical font components so that there is no need for multiple copies of the byte code in memory. Also, the byte code in data structure 305 can be read-only so that it will not change when memory is allocated for sharing.

Referring to Figures 2 and 3, in execution code, the execution manager 218 can find a reference (for example, an HTTP or other reference) that refers to source code in a document (for example, an HTML, XML, word processing, or other document) being parsed by the execution manager 218. The execution manager 218

IMPI.

INSTITUTO MEXICANO I de LA PROPIhtMD industrial

<img file="MX336964B_D0030.tif" />

You can first check to see if the current version of the byte code corresponding to the reference resides in the cache to query data structure 305. If the byte code resides in the cache, the execution manager 218 can get the byte code for execution. If the byte code does not reside in the cache, the execution manager 218 can get the source code from the source code location and can cause the source code to be collected and executed without delay (for example, without waiting code generator 216 to complete any of the important collection requests found in a row).

In one implementation, the byte code for the source code can reside in a directory parallel to the source code. For example, if the source code resides in C: / Package name / Source code / source code name.script file, the byte code, if any, may reside in C: / Package Name / Some Bytecode name / name .bytecode file.

In another implementation, the source code can reside on a remote device.

Figure 4 is a block diagram representing an illustrative arrangement of components of an environment in which the subject described here can operate. The components illustrated in Figure 4 are illustrative and are not intended to be all inclusive of components that may be required or included. In others . IMPI i INSTITUTO MEXICANO D £ LA PROPERTY *, INDUSTRIAL

<img file="MX336964B_D0031.tif" />

In mode s, the components and / or functions described collectively in Figure 4 may be included in other components (shown or not shown) or placed in sub-components without departing from the spirit or scope of the subject matter described herein. In some embodiments, the components and / or functions described in conjunction with Figure 4 can be distributed across multiple devices.

Turning to Figure 4, the environment 405 may include a target device 410, a network 4 15, a code server 417, and other components (not shown). Target device 410 and code server 417 may comprise one or more computing devices. Such devices may include, for example, personal computers, server computers, mobile or iaptop devices, multiprocessor systems, microcontroller-based systems, cable tv boxes, televisions, programmable consumer electronics, network PCs, minicomputers, macrocomputers, cell phones, personal digital assistants (PDAs), gaming devices, printers, gadgets including cable tv box, media center, or other gadgets, computing devices incorporated or attached to a car, other mobile devices, distributed computing environments including any of the above systems or devices, and the like. An illustrative device that may be configured to act as target device 410 or code server 415 comprises computer 110 of Figure 1.

<img file="MX336964B_D0032.tif" />

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL

<img file="MX336964B_D0033.tif" />

In one embodiment, the network 415 may comprise the Internet. In one embodiment, network 415 can comprise one or more local area networks, wide area networks, direct connections, virtual connections, private networks, virtual private networks, some combination of the foregoing, and the like.

Code server 417 may provide code to target device 410. In one embodiment, code server 417 may be a web server. In another embodiment, the code server 417 may be a machine within a private organization network that includes code on it. In other embodiments, the code server 417 may include any device capable of providing source code to the target device 410.

Target device 410 is a device on which code can be executed. The target device 410 can include a collection environment 420, a run environment 425, an installer 430, and a storage 435. The installer 430 can be implemented and act similar to the installer 215 of Figure 2 while storage 435 can be implemented. and act similarly to storage 220 of Figure 2.

The collection environment 420 may comprise a restricted rights environment in which the source code can be coupled into the byte code. In one embodiment, the collection environment 420 may comprise a virtual environment as described above. In another embodiment, the collection environment 420 may comprise a rights environment

<img file="MX336964B_D0034.tif" />

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL

<img file="MX336964B_D0035.tif" />

different restricted as previously described.

The runtime environment 425 may comprise an environment in which one-package software runs. In one implementation, the runtime environment 425 may comprise an Internet browser. In another implementation, the execution environment 425 may comprise a host procedure that is capable of executing software from a package that may include the source code.

Figures 5-6 are flowcharts that generally represent illustrative actions that may occur in accordance with aspects of the topic described herein. For simplicity of explanation, the methodology described in conjunction with Figures 5-6 is illustrated and described as a series of acts. It will be understood and appreciated that the aspects of the subject described herein are not limited by the illustrated acts and / or the order of acts. In one embodiment, the acts occur in an order as described below. In other modalities, however, the data may occur in parallel, in another order, and / or with other acts not presented and described here. In addition, not all illustrated acts may be required to implement the methodology in accordance with aspects of the subject described here. Furthermore, those skilled in the art will understand and appreciate that the methodology could alternatively be represented as a series of interrelated states through a state diagram or as events.

Turning to Figure 5, at block 505, the actions

IMPI

MEXICAN INSTITUTE OF INDUSTRIAL PROPERTY

<img file="MX336964B_D0036.tif" />

they start.

At block 510, a package is received that includes the software source code to install on a target device. For example, referring to Figure 4, the target device 410 may obtain a package from the code server 417. As another example, the installer 430 may be instructed to install a package coming out of storage 435.

At block 515, the package is installed on the target device. For example, referring to Figure 2, installer 215 can install the package in storage 220.

In block 520, a pointer is placed in a data structure such as a row or the like. The data indicator indicates that the source code of the package is to be collected in byte code. There can be a separate flag placed in the data structure for each source code file in the package. For example, referring to Figure 2, installer 215 can place one or more pointers in a data structure stored in storage 220.

At block 525, actions are taken to initially collect the source code unless a request is received to run the package software before initiating or completing the actions. These actions to collect the source code can include, for example:

1. Repeat through the data structure and find the indicator (s) indicating that the collection is necessary;

<img file="MX336964B_D0037.tif" />

two. Collect each applicable source code element found in step 1 above in byte code or some other code;

For example, referring to Figure 2, the code generator 216 can loop through the data structure and collect source code files for pointers found within the data structure. As another example, the 216 code generator can loop through a list of files and collect any file that has a given extension (eg, ".js" or another extension that indicates a source file).

At block 530, the compiled code can then be persisted in non-volatile memory. For example, referring to Figure 2, the cache manager 217 may store the code generated by the code generator 216 in storage 220. The code may be stored in volatile memory such as a memory or RAM cache for provide fast loading and running.

Block 535 is placed on the side of actions 520-530 to indicate that a request to run the package software may occur before, during, or after those actions. If such a request is received, other actions may be taken prior to initiating or completing the 520-530 actions. For example, if such a request is received before starting or completing the actions in blocks 520-530, the source code can be compiled and executed on an expedited basis. Other actions that describe what can

INSTITUTO MEXICANO // «j

OF THE PROPERTY

INDUSTRIAL - occur if such a request is received are described in conjunction with the

Figure 6.

At block 540, other actions can be performed, if any. For example, a regeneration trigger event may be received. In response, block actions 520-530 can potentially be performed again with different source code (if source code has changed) and second different code collected from different source code.

Turning to Figure 6, at block 605, the actions begin.

At block 610, a request is received to run software that includes the source code. For example, referring to Figure 2, execution manager 218 receives a request to execute software from a package installed on storage 220.

At block 615, a determination is made as to whether the code has already been collected and stored in non-volatile storage.

If so, the actions continue at block 640; otherwise the actions continue at block 620. For example, referring to Figure 2, execution manager 218 uses cache manager 217 to determine if the packet has already been collected and stored in storage 220.

Determining if the source code has already been collected may include reviewing the collected code in the known location of non-volatile storage. The known location can

MEXICAN INSTITUTE OF PROPERTY

INDUSTRIAL

<img file="MX336964B_D0038.tif" />

correspond to a name or other identifier of a package. For example, a known location can be a directory named after the package or a directory downstream of the directory. As another example, a known location can be a location indicated in a data structure that indicates where collected code is located, if any, for the code. As another example, a known location can be a location derived from a reference that identifies a source location (eg, a code server) of the source code where the source location can be reached over a network. In yet another example, determining if the source code has already been collected may involve checking a data structure stored in a file that places byte code for the package with source code for the package. The data structure can indicate if the second code has already been generated and is stored in the file.

At block 620, the source code is obtained. For example, referring to Figure 2, code generator 216 obtains source code from storage 220.

In block 625, the byte code (or other code) is generated from the source code. For example, referring to Figure 2, the code generator 216 creates byte code, machine executable code, or some other intermediate code from the source code obtained above.

In block 630, the code (or code derived therefrom, such as

<img file="MX336964B_D0039.tif" />

INSTITUTO MF.XIC.DE LA PROPERTY as executable code or other intermediate code) is executed. For example, referring to Figure 2, the execution manager 218 executes the code generated above.

At block 635, the code is persisted to non-volatile storage. Actions represented by block 635 may occur in conjunction with actions on or to be performed in a later period. For example, referring to Figures 2 and 3, code generator 216 can use cache manager 217 to place code for a packet in data structure 305 and store those data structures 305 in storage 220 for use. in subsequent execution of the software. As another example, at a later time, the code generator 216 may retrieve the source code and regenerate the collected code and store this collected code in storage 220.

At block 640, if the code has already been collected, the collected code is obtained. For example, referring to Figure 2, the execution manager 218 can get the byte code from the cache manager 217.

In block 645, the obtained code (or code derived therefrom such as binary code) is executed. For example, referring to Figure 4, the code can run in the 425 runtime environment.

At block 650, other actions can be performed, if any. For example, a file that includes a byte code can

<img file="MX336964B_D0040.tif" />

faith

MEXICAN INSTITUTE OF PROPERTY

....... ,. , INDUSTRIAL be distributed and shared by memory, through memory distribution, with a plurality of procedures ^ '

As another example, other actions might include checking if the compiled code was modified after it was generated and if so, get the source code back (which may be different from the original source code), recollect the source code, and storing the compiled code in non-volatile storage for use in subsequent execution of the software.

As can be seen from the detailed description above, aspects related to generating and caching software code have been described. Although the subject matter described herein is susceptible to various modifications and alternative constructions, certain illustrated embodiments thereof are shown in the drawings and have been described in detail above. However, it should be understood that there is no intention to limit the aspects of the claimed subject matter to the specific forms described, but rather, the intention is to cover all modifications, alternative constructions, and equivalents that fall within the spirit and scope of various aspects of the subject described here.

<img file="MX336964B_D0041.tif" />