Abstract: The disclosed computer-implemented method for protecting user data privacy by detecting the extension of tracker coverage of website browsing sessions through indirect data disclosure may include (i) navigating to an origin website during a new web browsing session, (ii) analyzing the origin website to detect clickable elements and tracking domains, (iii) identifying webpage navigation information for destination websites and resources loaded by the tracking domains, (iv) grouping the webpage navigation information for the destination websites by a common destination tracking domain, (v) determining web trackers extending a tracker coverage from the origin website to the destination websites, and (vi) performing a security action that protects against a potential invasion of user data privacy by providing a notification of the extended tracker coverage during a browsing session in the origin website. Various other methods, systems, and computer-readable media are also disclosed.

Abstract: A system with an interactive user interface for users to view and interact with sanitized log data received from a plurality of hosts, such as those associated with various services of an organization. The system may receive from hosts log files and/or metadata that have been filtered by agents executing on the respective hosts to remove or anonymize any sensitive or confidential information prior to transmission to the system. In some embodiments the system does further filtering of the sanitized data. Received sanitized data is parsed, indexed, and/or otherwise processed for optimal searching, and stored in a log pipeline. The system causes display of an electronic visualization interface.

Abstract: Techniques are described herein that are capable of detecting accidental algorithmic complexity of a procedure by using instrumentation. A number of times a parent procedure calls a child procedure during each of multiple executions of the parent procedure is detected by using instrumentation to provide call counts for the respective executions. A value of an attribute of the parent procedure during each of the executions is detected by using the instrumentation to provide attribute values for the respective executions. A function is generated that defines a curve that estimates a relationship between the attribute values for the respective executions and the call counts for the respective executions. Based at least on a slope of the curve, accidental algorithmic complexity of the parent procedure is determined. Based at least on the accidental algorithmic complexity satisfying a complexity criterion, a remedial action is performed with regard to the accidental algorithmic complexity.

Abstract: A computer-implemented method comprises detecting, by a processor of a first host of one or more hosts in a distributed computing environment, a distributed task waiting to be started, from a replicated configuration system, the distributed task being represented by a pending tasks key. The method comprises starting, by the processor, the distributed task by performing an atomic compare and swap operation to add a started key to the replicated configuration system. The method also comprises writing a specification of the distributed task to the replicated configuration system under a new version of a current tasks key. In addition, the method comprises removing, following the writing, the pending tasks key from the replicated configuration system.

Abstract: A system and method for real-time or near real-time anomaly detection and root cause automation in production environments or in other environments using shrunk dynamic call graphs are provided. The system includes an instrumentation agent that generates shrunk dynamic call graphs and exceptions/errors by injecting monitoring code or probes or call-tags into monitored application, a data agent that forwards collected data to the analysis engine over a network, an analysis engine that performs continuous clustering using machine learning, anomaly, and root cause detection. The system also includes a reporting module to report the anomaly.

Abstract: Various embodiments of the present technology generally relate to the characterization and improvement of software applications. More specifically, some embodiments relate to systems and methods for modeling code behavior and generating characterizations of the code behavior and interrelations based on the code models. Some embodiments include user interfaces that provide views into the characterizations and interrelations of the application features and components that can give developers insights quickly and efficiently into applications which may be used for future developments and modifications to the application and to avoid introducing bugs into the application.

Abstract: Embodiments of this disclosure include a data processing method. In the method, a training sample set that includes a plurality of graph computing task training samples is obtained. At least one performance indicator feature of each of the graph computing task training samples is extracted. The at least one performance indicator feature includes one or more of a graph data feature, a graph processing platform feature, a graph algorithm feature, and a machine hardware feature. A target performance prediction model is generated based on a mapping relationship between actual execution times of the graph computing task training samples and the performance indicator features. According to at least one performance indicator feature of an inputted graph computing task test sample, a predicted execution time of the graph computing task test sample is output based on the target performance prediction model.

Abstract: Embodiments of the present invention provide methods, systems, apparatuses, and computer program products for predicting consumer behavior. In one embodiment a method is provided comprising automatically creating a link graph comprising nodes representing webpages, links representing hyperlinks, and weights for each link representing a number of times a hyperlink associated with the respective link redirected the a user devices from a webpage associated with a first node connected to the link to a webpage associated with a second node connected to the link; and determining based on the link graph a programmatically expected path for a particular user, wherein the programmatically expected path identifies, at least, two or more webpages that the particular user is programmatically expected to visit and specifying a programmatically expected order at which the particular user will visit the webpages.

Abstract: Provided are a computer program product, system, and method for generating a visualization of blocks of code statements related to errors in a log file. A log file logs errors in execution of program code. Source code, from which the program code is compiled, is analyzed to determine blocks of statements in the source code whose execution resulted in the errors in the log file. Blocks of statements in the source code are annotated with the errors in the log file caused by the blocks of statements. Execution of a block of statements annotated with an error resulted in the error logged in the log file. The annotated blocks of statements are processed to generate a video providing a visualization of the blocks of statements in the source code whose execution resulted in the errors.

Abstract: In some examples, a system determines whether a chain of functions violates a constraint, based on accessing a tracking structure populated with entries as the functions are invoked by respective server processes launched during execution of a database operation, where each entry of the entries of the tracking structure identifies a respective invoked function that is associated with a corresponding program instance, and detecting, using the tracking structure, related functions that form the chain, the related functions being identified as related if associated with a same program instance. In response to determining that the chain of the functions violates the constraint, the system blocks an invocation of a further function to be added to the chain.

Abstract: Embodiments are directed towards previewing results generated from indexing data raw data before the corresponding index data is added to an index store. Raw data may be received from a preview data source. After an initial set of configuration information may be established, the preview data may be submitted to an index processing pipeline. A previewing application may generate preview results based on the preview index data and the configuration information. The preview results may enable previewing how the data is being processed by the indexing application. If the preview results are not acceptable, the configuration information may be modified. The preview application enables modification of the configuration information until the generated preview results may be acceptable. If the configuration information is acceptable, the preview data may be processed and indexed in one or more index stores.

Abstract: Technology for communicating by embedding messages in DNS requests/responses is disclosed. In many cases it is desirable for a device to communicate without that device having to supply network credentials. In some network environments, credentials are not required to send or receive DNS messages. The question section of a DNS request message may include a message for a destination DNS server and a query domain which, when using standard DNS routing, will result in the DNS request being directed to the intended destination DNS server. The message may be encoded in such a way that an algorithm run by the destination DNS server is able to parse the message from the DNS request.

Abstract: Methods and systems for structuring, storing and displaying time series data in a user interface. One system includes processors executing instructions to determine, from time series data from a first sensor, a first subset of time series data for the first batch from the first start time and the first end time, determine, from the time series data from the first sensor, a second subset of time series data for the second batch from the second start time and the second end time, generate a time series user interface comprising a chart, the chart including a first plot for the first subset of time series data and a second plot for the second subset of time series data, the first plot being aligned to the second plot, and cause presentation of the time series user interface.

Abstract: Disclosed are systems, methods, and non-transitory computer-readable storage media for managing project tasks using content items. A user can create tasks within a content item. The tasks can be assigned to users and/or be assigned due dates. The content item can be shared with other users such that updates to the content item (e.g., updates to the tasks) can cause sending notifications to users associated with the content item. When a task in the content item is updated, all members of the project can be notified of the updated status of the task. A task list for a project can be created that aggregates tasks from multiple content items associated with the project. Tasks can be organized in the task list according to the content item the task was created in. Updates to tasks in the task list can cause corresponding updates to the tasks in the content items.

Abstract: A computer-implemented method for debugging an executable control flow graph that specifies control flow among a plurality of functional modules, with the control flow being represented as transitions among the plurality of functional modules, the computer-implemented method including: specifying a position in the executable control flow graph at which execution of the executable control flow graph is to be interrupted; wherein the specified position represents a transition to a given functional module, a transition to a state in which contents of the given functional module are executed or a transition from the given functional module; starting execution of the executable control flow graph in an execution environment; and at a point of execution representing the specified position, interrupting execution of the executable control flow graph; and providing data representing one or more attributes of the execution environment in which the given functional module is being executed.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for optimizing a plan for one or more robots using a process definition graph. One of the methods includes receiving a process definition graph for a robot, the process definition graph having a plurality of action nodes, and the plurality of action nodes including a plurality of motion nodes that were previously split from a single motion node due to a conflict with a second motion node representing a second motion to be performed by another robot; determining that the conflict with the second motion node no longer exists; and in response to determining that the conflict with the second motion node no longer exists, modifying the process definition graph including combining the plurality of motion nodes into a new single motion node representing all of the motions of the plurality of motion nodes.

Abstract: Embodiments of apparatus, systems, and methods are described for creating, arranging, and displaying data mappings between two different data schemas in a graphical user interface (GUI). The GUI allows scaling of a data schema, automatic data sorting and grouping of objects in a schema, dynamic spacing of data mappings in the GUI, and customizable data map transformations to entities of a canonical data model. The GUI can limit the display of objects and fields to those that have been mapped into entity groups. The GUI can display mapped or unmapped fields to facilitate the mapping of additional fields or objects. The GUI displays visual logic connectors between objects and entities to summarize the relationship and number of mappings between the objects and entities. Objects and entities can be expanded and collapsed to show more granular relationship information. Instance-enabled canonical entities can be created to conceptually group fields.

Abstract: A non-transitory computer-readable recording medium stores a failure cause identification program for causing a computer to execute a process including: collecting process information related to one or more processes that operate in a container environment; obtaining a derivative relationship of a process for each container on the basis of the process information; generating symbol information in which a function of each of the processes is associated with a container in which each of the processes operates according to the derivative relationship of the process for each container; generating an aggregation result in which a frequency of the function is aggregated according to the symbol information; and identifying a cause at a time of failure occurrence on the basis of the aggregation result.

Abstract: Aspects of the disclosure relate to application assessment. A computing platform may receive content information and manual input data corresponding to hierarchical content. The computing platform may establish a content tree indicating relationships between pages of the hierarchical content. The computing platform may receive starting/ending pages of the hierarchical content and application assessment commands. Using the content tree and in response to receipt of the application assessment commands, the computing platform may generate error information based on the starting page and the ending page by performing a holistic error analysis of the hierarchical content between the starting page and the ending page, which may include automatically populating manual input fields using the manual input data.

Abstract: A method for managing a modular product life cycle is described. A central computing device or system receives inputs representative of one or more of: an expected product life cycle, a market demand for the product, a manufacturing process for the product, a reverse manufacturing process for the product, and one or more technical engineering constraints associated with the product. From this information, a first modular product design is determined. Later in the life cycle of the modular product a second plurality of inputs representative of one or more of: a market demand, a manufacturing process, a reverse manufacturing process, and one or more technical engineering constraints are retrieved. From this information, a second modular product design is determined.

Abstract: Techniques are disclosed to provide enhanced online security. A network server actively monitors data between a network server hosting a website and a computing device. Some of the disclosed techniques leverage “cookie stitchers” to associate user data, which may include a website identifier, to the user's computing devices. These techniques allow the network server to block access to explicitly identified computing devices, or to trigger two-factor authentication.

Abstract: Mitigating website privacy issues by automatically identifying cookie sharing risks in a cookie ecosystem. In some embodiments, a method may include generating, by the computing device, a cookie tree representing cookies created on a web browser while browsing a website. The cookie tree may include nodes representing organizations. The cookie tree may further include hierarchical edges between the nodes representing creation chains of the nodes. The method may also include determining, by the computing device, a creator, a sender, and a receiver of each of the cookies. The method may further include mitigating, by the computing device, website privacy issues based on the creator, sender, and receiver of each of the cookies.

Abstract: A time series data display device includes a display unit that outputs display data regarding the time series data. The display unit includes a general display generation unit that generates general display data for general display of a general tendency of the time series data and a detailed display generation unit that generates detailed display data for detailed display of detailed individual values of the time series data. The general display displays frequency or density of individual data configuring the time series data at each position of the time series data on a rendering plane, with a visual effect in accordance with the frequency or the density.

Abstract: A trace anomaly grouping and visualization technique logically groups traces with anomalies to cases to enable software developers to monitor, diagnose and visualize the anomalies, as well as to solve the anomalies during application development and production. A client library of an investigative platform collects signals from traces (trace signal information). The technique organizes (groups) related trace signals of methods with anomalies (e.g., exceptions, performance abnormalities such as slowness) into datasets (denominated as “cases”) based on common cause for an anomaly and correlates the signals to identify a case. The collected information may be used to differentiate between root causes of the anomalies using a comparative visualization of traces displayed on a standard user interface of the investigative platform.

Abstract: A system including one or more processors and one or more non-transitory computer-readable media storing computing instructions configured to run on the one or more processors and perform: modeling a webpage as a random field, wherein the random field comprises an undirected graph comprising nodes and edges; identifying a cyclic dependency in the undirected graph, wherein the cyclic dependency involves at least three of the nodes; breaking one or more of the edges of the undirected graph that connects the at least three of the nodes in the cyclic dependency; determining a probability of the webpage having exceeded a predetermined threshold based on compatibility functions of the edges, as updated; and sending instructions to display the webpage based at least in part on the probability of the webpage having exceeded the predetermined threshold. Other embodiments are described.

Abstract: A monitoring system monitors processing of incoming messages by an application, and logs data related to performance of the application. The application includes a plurality of checkpoints, and the monitoring system logs data upon each message traversing the checkpoints in the application. The monitoring system is configured to dynamically modify checkpoints within the application based on latency detection of portions of the application, resulting in improved granularity/resolution of the data collected from congested portions of the application, and reducing the performance penalty of the monitoring system from portions of the application that are not congested.

Abstract: Features for analyzing one or more images with image recognition to detect bounds to accurately convert physical text (e.g., pilot logbooks, aviation-related documents, journey logbooks, aircraft mechanics work orders, airframe logbooks, propeller logbooks, and engine logbooks) into digital format. Based on the predefined bounds, character recognition, e.g., OCR/ICR/ICR engine(s), may be used to convert each cell to a digital format. A decision engine determines, based on reinforcement learning data, the correct value of each cell based on a confidence of the character recognition. The decision engine may be a series of logical filtering, sorting, context rules (e.g., REGEX rules for specific columns) and suggestions based on the reinforcement learning model used to normalize the imperfections associated with the character recognition technologies. The final result is a serialized digital format that can be exported to an endpoint (e.g., spreadsheets, database, etc.).

Abstract: Disclosed are implementations for software debugging and application development, including a software debugging method that includes receiving from a remote device, by an instrumentation agent operating at an application system, one or more instrumentation requests for application data resulting from execution of an application process on the application system, processing the instrumentation requests to generate injection point objects, inserting the objects into code (e.g., bytecode) of the application process, and capturing blocks of application data resulting from the inserted one or more injection point objects.

Abstract: A method for securely testing a web application is provided. The method may include analyzing each HTTP log entry that may be included in a centralized web server log file of a web application. Each HTTP log entry may include an endpoint. The endpoint may be a URL path correlating to a location on the web application. Based on the analysis, the method may include identifying each endpoint included in the web application and generating a first web application site-map based on each identified endpoint. The method may further include determining one or more endpoints on the first web application site map, that may be absent from a second web application site map. The second web application site map may include each crawled endpoint within the web application identified via a crawling of the web application by a web application attack tool for identifying security vulnerabilities.

Abstract: Techniques for profile clustering for homogenous instance analysis are described herein. An aspect includes collecting for each of a plurality of homogenous instances in a cloud computing environment, respective profiling information, the profiling information comprising counter data. Another aspect includes identifying a code unit for analysis. Another aspect includes aggregating counters corresponding to the code unit for each of the plurality of homogenous instances from the respective profiling information. Another aspect includes determining a cluster comprising a subset of the plurality of homogenous instances based on the aggregated counters.

Abstract: There is provided a system for debugging a computer program comprising computer readable program code. The system comprises, debugging data indicating an execution of the computer program, first and second user devices, configured to display a first and second graphical user interface respectively, each graphical user interface comprising data indicative of an execution of a debugger processing the debugging data. The first and second graphical user interfaces are each configured to display data indicative of a temporal position of the execution of the computer program associated with the other one of said graphical user interfaces, and display data indicative of a position within the computer readable program code associated with the other one of said graphical user interfaces.

Abstract: In some examples, octree serialization can include non-transitory machine-readable medium storing instructions, the instructions executable by a processing resource to evaluate two or more nodes sequentially in an octree structure until a leaf node is reached, wherein the two or more nodes include at least one non-leaf node, and generate a serialized octree document based on a respective node identifier in a header associated with each node of the two or more nodes.

Abstract: The present approach relates to facilitating the diagnosis of one or more performance issues associated with running an application (and widgets in the application) on a client instance hosted by one or more data centers by allowing script comparison, configuration comparison, and so forth, all in one interface, without the need for a user to navigate between various windows and/or interfaces. In accordance with the present approach, one or more performance issues are determined based on a first set of data indicative of an initial version of the application and a second set of data indicative of a customized version of the application. After determining the one or more performance issues, a visualization of diagnosis data associated with one or more widgets may be generated in response to executing the customized application to categorize the one or more widgets based on a severity of the one or more performance issues.

Abstract: According to an embodiment, a system and method are provided for supporting interactive debugging of embedded software (ESW) on a simulation platform. A processor model within the simulated system will support a register and memory tracing sub-module. Simulator and emulator breakpoints will be used with the modeled objects within the tracing sub-module. For example, a simulator breakpoint may be set for the task or function that buffers the trace information so it can be written to a file. A database of register and memory values which represent the complete history of register and memory value changes during a simulation can be created from trace information and can be accessed to non-intrusively obtain any processor register or memory value during simulation. The processor register and memory values of the database can also be accessed to symbolically show the behavior of ESW concurrently with hardware behavior in the simulation.

Abstract: A method may include executing operation types on a concurrent data structure to obtain executed operations. Each executed operation may cause a transition from a preceding state to a subsequent state. The method may further include recording each executed operation to obtain recorded operations, and assembling a concurrent history from the recorded operations. The concurrent history may include a subset of the recorded operations, and the concurrent history may impose overlapping and non-overlapping relationships on the subset of recorded operations. The method may further include checking whether the concurrent history has an equivalent linearization including a total sequential ordering of the subset of recorded operations, and reporting an error when the concurrent history has no equivalent linearization.

Abstract: An apparatus and method for visualizing data. The apparatus for visualizing data includes a behavior information collection unit for executing an application from which information is to be collected and collecting behavior information from a process of the executed application, a behavior feature extraction unit for extracting behavior features in an order in which the behavior information is called, a behavior sequence generation unit for generating a behavior sequence by arranging the behavior features in chronological order, and a behavior sequence visualization unit for visualizing the behavior sequence as a 3D sequence object.

Abstract: Execution performance of software code is analyzed by converting values of profiling metrics, obtained by at least one software profiling tool in respect of at least one computer software code, into images using a profiling metric conversion process. The conversion process may comprise identifying a set of profiling metrics with synonymous labels within a plurality of labeled profiling metrics whose values are to be converted, using at least one natural language processing scheme, matching all profiling metrics in the set to the same label, and, for each set of profiling metrics, converting values corresponding to the profiling metrics in the set into respective images such that all the converted images have the same image format. The comparison method further comprises computing at least one of similarities and differences between at least two of the images, and comparing execution performance of the software code(s) corresponding to the two images based on the results of the computation.

Abstract: Some examples described herein relate to dynamically applying a patch to a shared library. An external process may be invoked to bring target processes that refer to a shared library, to a safe point. In response to a function call from a target process, amongst the target processes, to access a target function in the shared library, the function call may be forwarded to a special function in a dynamic loader, wherein the target function is a function to be patched in the shared library. The special function may determine whether a shared patch library, comprising a patched version of the target function or a new function, is loaded for the target process. In response to determination that the shared patch library is not loaded for the target process, the shared patch library may be loaded only for the target process, and the request for the target function may be routed to the patched version of the target function or the new function, in the shared patch library.

Abstract: The system includes an ATE which produces a plurality of test signals and test results for electronic devices by a test instrument or instruments therein. An execution engine responsive to the test results runs multiple test operations from the test instruments within a coherent time domain and maintains a temporal relationship between the multiple test results. The multiple test signals and test results are then displayed in a time coherent alignment.

Abstract: Optimizations are provided for sibling calls. A sibling caller is marked to indicate that it may call a sibling routine or that it may call an external sibling routine. Based on the marking, certain processing is performed to facilitate use of sibling calls, particularly when the sibling routine being called is external to the caller.

Abstract: A condition determination device includes an acquiring unit, a specifying unit, a classifying unit, and a condition determining unit. The acquiring unit acquires a total execution history, which is an execution count for each component included in a program, when a test is performed by supplying a plurality of input data to a target device which executes the program. The specifying unit specifies a shortage component of which the execution count indicated by the total execution history does not satisfy test criteria among components included in the program. The classifying unit classifies each of the input data into first data, which causes the target device to execute the shortage component, and second data, which does not cause the target device to execute the shortage component. The condition determining unit determines a condition of input data having a common characteristic with the first data.

Abstract: A method and apparatus for tracing instruction streams for a multi-threaded processor are disclosed herein. In one embodiment, the apparatus includes a last thread register configured to store a thread index that indicates a last executed thread, a tracing memory configured to store, within each of a plurality of storage locations, state information corresponding to a dispatch cycle for a multi-threaded processor, and a tracing control module configured to provide the state information to the tracing memory. The state information includes instruction information and a previous thread index. The state information may also include a flip bit that is used to determine a current insertion point within the tracing memory. A corresponding method is also disclosed herein.

Abstract: Data is received that includes at least a portion of a program. Thereafter, entry point locations and execution-relevant metadata of the program are identified and retrieved. Regions of code within the program are then identified using static disassembly and based on the identified entry point locations and metadata. In addition, entry points are determined for each of a plurality of functions. Thereafter, a set of possible call sequences are generated for each function based on the identified regions of code and the determined entry points for each of the plurality of functions. Related apparatus, systems, techniques and articles are also described.

Abstract: Disclosed is an RTE code generating method including: extracting information of an application by analyzing a plurality of template files; analyzing an operation time for the information of the application with reference to a database of operation times for Run Time Environment (RTE) generation codes; and generating RTE code generation information for the application based on the analysis result. According to the present invention, application software in which operation timing and operation stability are secured can be developed by generating RTE code generation information for an application in consideration of an actual operation time of the application.

Abstract: Among other things, a method includes, at a computer system on which one or more computer programs are executing, receiving a specification defining types of state information, receiving an indication that an event associated with at least one of the computer programs has occurred, the event associated with execution of a function of the computer program, collecting state information describing the state of the execution of the computer program when the event occurred, generating an entry corresponding to the event, the entry including elements of the collected state information, the elements of state information formatted according to the specification, and storing the entry. The log can be parsed to generate a visualization of computer program execution.

Abstract: Embodiments for integrating production support features are included in systems for receiving modules from a client application associated with an operator device. The embodiments include selecting at least one client module from the received modules, identifying a trace objective for the at least one client module, selecting a data collection level based on the trace objective, and collecting, by a processor, data associated with the at least one client module in response to the selected data collection level. The systems are combinable with additional production support features including event monitoring.

Abstract: Embodiments for integrating production support features are included in systems for receiving modules from a client application associated with an operator device. The embodiments include selecting at least one client module from the received modules, identifying a trace objective for the at least one client module, selecting a data collection level based on the trace objective, and collecting, by a processor, data associated with the at least one client module in response to the selected data collection level. The systems are combinable with additional production support features including event monitoring.

Abstract: A performance profiling apparatus includes: a plurality of counters provided for a routine included in a program; a storage section configured to store an instruction of the program and an identification information indicating the routine of the program; a processor configured to read the instruction from the storage section and to execute a process according to the instruction; and a counter controller configured to, at the time of reading the instruction of the processor, receive the identification information of the instruction which is output from the storage section with the instruction and to instruct a first counter designated by the identification information to count up.

Abstract: An analysis and visualization depicts how an application is leveraging computer processor cores in time. The analysis and visualization enables a developer to readily identify the degree of concurrency exploited by an application at runtime. Information regarding processes or threads running on the processor cores over time is received, analyzed, and presented to indicate portions of processor cores that are used by the application, idle, or used by other processes in the system. The analysis and visualization can help a developer understand contention for processor resources, confirm the degree of concurrency, or identify serial regions of execution that might provide opportunities for exploiting parallelism.

Abstract: Techniques are described for providing recommendations to enhance the logging code in a computer program. In particular, the methods described herein can identify source code locations which lack log printing statements or contain noisy log printing statements. The methods analyze static call graph of the source code, the corresponding commit and bug history, and propose recommendations to enhance logging. The logging behavior in methods whose log printing statements have been significantly modified can be considered to be ideal. The analysis discovers such methods and quantifies their logging behavior. It then compares this logging behavior with the logging behavior of highly critical and/or less critical methods to generate logging enhancement recommendations.