Is both a programming language and a software environment for statistical computing and research, and offers robust data analytics and information processing capabilities. It includes powerful tools to analyze and interpret data, particularly via its graphing and plotting capabilities, and is popular among data scientists and programmers alike. WRDS provides a direct interface for R access, alowing native querying of WRDS data right within your R program.
All WRDS data is stored in a PostgreSQL database, and is available through R via a native R Postgres driver. Here is an example of a simple query against the Dow Jones Averages & Total Return Indexes using R: res. Full usage and many examples are given throughout this document. There are two ways to access WRDS data with R:.
R on the WRDS Cloud - You SSH to the WRDS Cloud and run batch or interactive R jobs on our high-performance computing cluster. This method benefits from our strong computing resources with direct access to the data, high available memory and CPU count, and powerful job management. This method is appropriate for highre using it in your research! Before You Begin. The following resources may be helpful to you as you begin using R at WRDS.
CCleaner for Mac! Clean up your Mac and keep your browsing behaviour private with CCleaner, the world's favourite computer cleaning tool. Free download. Digital marketing breaks down this complex process into individual, achievable goals and outlines and defines a clear path to success. The acute ability of the web to generate a wealth of new customers, clients, and income for businesses makes digital marketing and all of its sub-areas a must-have in 2018 and beyond.
If you intend to run batch or interactive R jobs on the WRDS Cloud, this document contains everything you need: from SSH access to job management to quota reporting. If you intend to run R via RStudio on your workstation and connect remotely to WRDS, it might be helpful to be familiar with RStudio itself, though this document will provide enough information to get you started. If you are new to R or could use a refresher, the R Project provides its own comprehensive introduction guide.
Additionally, if you are planning on running interactive or batch jobs on the WRDS Cloud, you should have an understanding of basic UNIX commands and how to use a UNIX-like text editor, such as: nano, emacs, and vi, which are all available on the WRDS Cloud. R on the WRDS Cloud.
R jobs on the WRDS Cloud can be run either interactively or in batch mode:. Interactive jobs are sessions where you input commands in serial within an interactive shell, receiving a response to each command after you enter it. Interactive sessions are the best choice for quick tests, for accessing and working with straightforward data segments, or when working on a program and trying out commands as you write them. Batch jobs are longer programs that might need to perform several steps to generate a result. Batch jobs are the best choice when running multi-step jobs that may run over the course of several hours or days.
Jobs on the WRDS Cloud are managed by a process called Grid Engine, which accepts job submissions and distributes them to the least-loaded compute system available. Grid Engine is very powerful and offers many features for fine-tuning your jobs and thier performance, and also allows for robust job management. This document will include just enough to get you started submitting your R jobs to the WRDS Cloud Grid Engine, but a far greater degree of detail is available for the curious in the. Both interactive jobs and batch jobs are discussed in detail below. WRDS Cloud: Preparing your Environment. The first step to connecting to WRDS data from within R on the WRDS Cloud is setting up your.Rprofile file in your WRDS Cloud home directory. This step only needs to be done once.
The.Rprofile file first loads the RPostgres package, then creates a connection to WRDS with all the necessary parameters and saves that connection as wrds. By doing this, we can freely refer to this connection by the connection name wrds anywhere in our R programs and our code will seamlessly connect to the WRDS PostgreSQL servers and download the data you've requested.
To create your.Rprofile file, SSH to the WRDS Cloud (if you're new to the WRDS Cloud or need a refresher, consult the on how to do this), create a new file named.Rprofile directly in your WRDS Cloud home directory (you can use any editor to do this, such as nano or vi), and place the following configuration in that file: library(RPostgres) wrds. Interactive R sessions allow you to execute R code in serial within a shell, receiving a response to each command as you enter it.
Many users chose to work in an interactive session to formulate the various data steps that accomplish a given task, before then building a batch job from these data steps and executing the job. Interactive R sessions are also a good way to ensure that the.Rprofile file we just created is working as expected, so let's start with an R interactive session on the WRDS Cloud. In order to run an interactive R session, you will need to schedule an interactive job with the WRDS Cloud Grid Engine software. The following example shows such a connection, submission, and interactive R session.
Following the example, you'll find an explanation of the steps. Example: myuser@mylaptop $ ssh wrdsuser@wrds-cloud.wharton.upenn.edu Password: wrdsuser@wrds-cloud-login1-h $ qrsh wrdsuser@wrds-sas6-h $ R -no-save -no-restore res data dbClearResult(res) data quit wrdsuser@wrds-sas6-h $ logout wrdsuser@wrds-cloud-login1-h $. A description of the above WRDS Cloud SSH connection and R interactive session line-by-line:. From mylaptop I make an SSH connection to wrds-cloud.wharton.upenn.edu with my WRDS username wrdsuser. I enter my WRDS password when prompted. Once logged into the WRDS Cloud, I submit an interactive job to the WRDS Cloud Grid Engine with qrsh. I am assigned to the interactive compute node wrds-sas6-h and given a prompt.
I start an interactive R session without using R's session management features. Once R starts up, I use dbSendQuery to prepare a SQL query against the wrds connection that we had already established in the.Rprofile file. I use dbFetch to fetch the data gathered from the above SQL query. I use dbClearResult(res) to close my connection (and avoid a warning message).
I print the data back to my console just to prove it worked. When I am done with my interactive R session, I quit. I am returned to my prompt at the interactive compute node wrds-sas6-h. I issue the logout command. I am returned to the WRDS Cloud head node wrds-cloud-login1-h, and am ready to issue another job. I could also have remained on wrds-sas6-h if I wanted to submit additional interactive jobs.
Instructions for accessing WRDS data once connected are given in the Accessing Data From R section of the document. WRDS Cloud: Batch Jobs. Batch jobs on the WRDS Cloud allow for long-running, multi-step program execution, and are ideal for more in-depth computational analysis of data. Batch jobs are submitted on the WRDS Cloud to a central Grid Engine, which handles the scheduling, resource management, and execution of the submitted job. For more information on the WRDS Cloud and its Grid Engine, please consult the. An R batch job is comprised of two files:. The R program itself, with file extension.r, that contains the R code to be executed.
A wrapper shell script, with file extension.sh, that submits the R program to the Grid Engine An R batch job relies on the presence of an.Rprofile file to connect to WRDS, just like an interactive job does. If you haven't already, be sure you've created this file as described in the WRDS Cloud: Preparing Your Environment section above. Because we have already defined the connection to WRDS in our.Rprofile file, we can simply refer to the connection by its established name, wrds, anywhere in our R program. To demonstrate, let's create an R program for this batch submission that returns the Dow Jones Index by date.
In your WRDS Cloud home directory, create a program named myProgram.r with the following code: res. Where:. Sets the shell of the wrapper script to bash. Tells Grid Engine to look in the current working directory ( cwd) for any referenced files, and to store output files in that same directory as well. Runs the myProgram.r program in R BATCH mode without saving or restoring my R session. The following additional lines may also be helpful in your wrapper script: #!/bin/bash #$ -cwd #$ -m abe #$ -M youremail@yourinstitution.edu echo 'Starting job at `date`' R CMD BATCH -no-save -no-restore myProgram.r echo 'Finished job at `date`'.
Where:. Sets the shell of the wrapper script to bash. Tells Grid Engine to look in the current working directory ( cwd) for any referenced files, and to store output files in that same directory as well. Instructs Grid Engine to send a notification Email at stages: before, after, and at error (if applicable).
Specifies the address to send the above Emails to. Uses the command echo to send a bit of text and the current timestamp to an output file just before starting my R program. Runs the myProgram.r program in R BATCH mode without saving or restoring my R session.
Uses the command echo to send a bit of text and the current timestamp to an output file just after finishing my R program. WRDS Cloud: Submitting a Batch Job. The WRDS Cloud Grid Engine will then verify your job submission and schedule it to run on the currently least-utilized compute node in the cluster. When your job completes, all output files will be written to your current working directory (as described in the next section). To view the status of a currently-running R job on the WRDS Cloud, use the qstat command. If no results are given, you have no jobs running.
Please consult the for more information on working with the Grid Engine on the WRDS Cloud, including job monitoring, queue selection, and much more. WRDS Cloud: Batch Job Output. When your batch job completes, several output files will be created containing the results of your job. Since we used the #$ -cwd parameter in our wrapper script, these files will be created in the same directory as the wrapper script itself. Assuming the job you ran was called 'myProgram.sh' which calls the R program 'myProgram.r', these output files are:.
myProgram.r.Rout - The output file of your R program, containing the collection of observations that your code generated. These are your results.RData - The workspace file that saves your program's objects and functions if you did not use the -no-save parameter to R. myProgram.sh.o###### - The Grid Engine file that contains all output from your myProgram.sh wrapper (such as the echo commands). myProgram.sh.e###### - The Grid Engine file that contains all errors from your myProgram.sh wrapper. This will be empty if your program's execution did not experience any errors. Where ###### is the Grid Engine job number.
Note that if you run your program again, the second run will overwrite your previous output file myProgram.r.Rout with the new results. You may wish to rename the outputfile to something else before you run your R program again, should you wish to keep it. The easiest way to rename a file is the mv command, like so: mv myProgram.r.Rout previousresults1. The WRDS Cloud also supports connecting via a remote R interface to access WRDS data. This allows you to program from the comfort of your own computer, using your own tools and resources. This can be done with one of many R interfaces, both graphical and command line, including, R's own shell, and many others. RStudio is probably the most popular of these, and is available for Mac, PC, and Linux, so this document will focus on RStudio - but instructions should be similar for other R interfaces as well.
RStudio: Installing and Preparing Your Environment. If you haven't already, download the latest version of R and RStudio for your platform:. Starting RStudio should launch an interactive R session for the version of R you just installed, and present you with a prompt. Check that you are able to run a few simple test R commands within RStudio before your proceed. Note: WRDS supports only R 3.4 or later for use with WRDS data.
Versions previous to R 3.4 have various issues interfacing with the RPostgres module and may not install RTools properly. Installation Prerequisite for Mac OS X: If you are running OS X, you will need to install Postgres on your system before proceeding. You can do this via Homebrew, as follows: 1.
Start a Terminal session on your Mac by opening a Finder window and navigating to Applications, then Utilities. Double-click on the Terminal icon to start it. Install Homebrew by following the installation instructions on the Homebrew webpage:. Copy the command under 'Install Homebrew' from your browser and paste it into the Terminal window you just opened. You will be asked for the password for your local Mac user account (not your WRDS account).
Detailed/alternative installation instructions are available. After Homebrew is finished installing, install Postgres by typing brew install postgres in the Terminal window.
The first time you install packages with devtools::installgithub, R may display an 'Install Build Tools' prompt similar to the below image. In order to proceed, you must click 'Yes'. R Studio will then download and install the Rtools package. This package contains a C compiler and associated tools used to build R packages from source code. While it is installing Rtools, the devtools::installgithub command may fail with an error message saying that the Rtools package is not installed.
If that occurs, simply rerun the command after the Rtools installation has finished, and it should complete successfully. If you have problems with the above procedure, please try the following: 1. Make sure you are using R 3.4 or later. Versions previous to 3.4 may work, but are unsupported. If you are running OS X and get the error Configuration failed because libpq was not found, then you need to install Postgres as well. You do this by, then using Homebrew to install postgres (with the command brew install postgres, entered directly on the command line, not in R). After doing so, try the above package installations again.
If you are running Windows and receive a prompt asking to compile a binary version of openssl, select no. The tools will use a pre-compiled version for your OS. If you are familiar with the previous SAS-based method of connection, it was required that you download two SAS drivers (Java Jar files) and set up an.Renviron file. With the WRDS Postgres connection method, these steps are no longer required. Next we need to create your.Rprofile file, and include within it connection parameters to WRDS, just as on the WRDS Cloud. Note: If you did previously use this workstation to connect to WRDS using the SAS method, you should rename your existing.Rprofile and.Renviron files as backups so that they do not interfere with the new Postgres connection method.
Something like.Rprofile.bak and.Renviron.bak should suffice. Or you may simply delete them if you do not need them anymore. The file should be placed in the location that you have set in RStudio as the Default Working Directory (when not in a project), which is your user home directory by default.
The default configuration for OS X, for example, is available from the RStudio Preferences menu and looks like the following. Where 'yourusername' is your WRDS Username and 'yourpassword' is your WRDS Password. IMPORTANT: Be sure to include an extra blank line at the end as well (i.e. Press 'Return' at the end of the final line), otherwise RStudio won't be able to parse the file.
Save the new file as.Rprofile and click Save. If you are warned about creating a file that begins with a period, be sure to select to do so anyway. Be sure that your filename matches.Rprofile exactly, it must start with a period and not have an extension (such as.txt) in order for R to be able to read it properly. While you should normally be wary of placing any password in cleartext in a file like this, this file resides in your home directory on your workstation, which shouldn't be accessible to any other user. Be sure, however, to lock your computer when you walk away from it, or log out from your workstation user account when done with it.
Quit and relaunch RStudio to make sure your.Rprofile file is working properly. Upon relaunching, you should see the wrds connection in the Environment section of RStudio, and you should get the following response when you type wrds at the RStudio prompt: wrds@wrds-pgdata.wharton.upenn.edu:9737. From now on, everytime you launch RStudio, R will start up a connection to WRDS and have it ready for you to use as wrds in any R program. Alternatively, if you don't want RStudio to automatically make a connection to WRDS when you launch it, you can delete your.Rprofile file, or at least remove the stanza beginning with wrds. Whether you are accessing data on the WRDS Cloud via an interactive or batch job, or are connecting remotely via R or RStudio, the method for accessing WRDS data once connected is the same. Recall that when we set up our environment earlier in the.Rprofile file, we created the variable wrds to access our connection to WRDS in any R program.
Now that we are connected, we can use the variable like so: res. Where:.
dbSendQuery uses the already-established wrds connection to prepare the SQL query string and save the query as the result res. SELECT. FROM dataset is a standard SQL query. The next few sections explore the kinds of SQL queries you can execute in this manner. dbFetch fetches the actual data that results from running the SQL query res against wrds and stores it as data. If you are querying a large amount of data or a wide date range, this step could take some time. n=-1 is an optional parameter allowing you to limit the number of returned observations.
N=-1 is the default and returns an unlimited number of rows (all matching rows). N=10, for example, would instead only return the first 10 rows. This is a great way to test a SQL statement against a large dataset quickly. dbClearResult(res) properly closes the connection, readying us for another query when we are ready. data is the data retreived from WRDS. While this value would usually be manipulated further in a research application, here we just call it on its own line for easy data verification.
NOTE: If you are familiar with the previous SAS-based method of connection, you may have used 'SAS SQL' for the SQL statements when querying. This is not the case with this PostgreSQL connection: the SQL you use in querying WRDS data is standard SQL. Let's use this syntax to get an overview of the data available to us in the next section. Querying Metadata - Examining the Structure of Data. When working with WRDS data, it is often useful to examine the structure of the dataset, before focusing on the data itself. WRDS data is structured according to vendor (e.g. Crsp) and referred to as a library.
Each library contains a number of component tables or datasets (e.g. Dsf) which contain the actual data in tabular format, with column headers called variables. We can analyze the structure of the data available to us through its metadata by querying the special informationschema table, as outlined in the following steps:. List all avaialble libraries at WRDS.
Select a library to work with, and list all available datasets within that library. Select a dataset, and list all available variables (column headers) within that dataset. NOTE: When working with the PostgreSQL informationschema table, libraries and datasets that you provide are case-sensitive, and must be lowercase. This applies to both informationschema.tables and informationschema.columns.
Let's run through each of these three steps to examine the structure of our data. To determine the libraries avaialble at WRDS: res.
This will list all libraries available WRDS. Though all libraries will be shown, your institution must still have a valid, current subscription for a library in order to access it via R, just as with SAS or any other suported programming language at WRDS. You will receive a helpful error message indicating this if you attempt to query a table to which your institution does not have access. NOTE: The TAQ dataset is the only dataset where tabletype = 'FOREIGNTABLE', a consideration made, again, due to its size. If you do not intend to perform any research against TAQ, you may freely omit that or statement. To determine the datasets within a given library: res.
Where 'library' is a dataset such as crsp as returned from #1 above and 'dataset' is a component database within that library, such as dsf, as returned from query #2 above. Remember that both the library and the dataset are case-sensitive! The above queries help to establish the structure of the data we're trying to access; ascertaining the exact dataset and variable names we'll need to use when we go to access the data itself in the next section. Alternatively, a comprehensive list of all WRDS libraries is available via the.
This online resource provides a listing of each library, their component datasets and variables, as well as a tabular database preview feature, and is helpful in establishing the structure of the data you're looking for in an easy, web-friendly manner. NOTE: If you are familiar with the previous SAS-based method of connection, you used the SAS dictionary table for this. That table required exclusively uppercase libnames and memnames, while this PostgreSQL method requires exclusively lowercase libraries and datasets. Be sure to update your code! Querying Data - Accessing the Data Itself. Now that we know how to query the metadata and understand the structure of the data, we can construct a data query to start gathering the actual data itself.
Unlike the above metadata queries, where tableschema and tablename are separately used to seach libraries and datasets respectively, data queries instead use the two together to identify the data location. So, for example, a data query for the dataset dsf within the library crsp would be referred to as crsp.dsf.
The following demonstrates this example: res. IMPORTANT: Setting n=10 artificially limits the results to 10 observations. The table crsp.dsf is CRSP's Daily Stock File and tracks thousands of stocks over almost a hundred years: a query that returns all observations would take a very long time. In reality, most queries are far more specific, as shown in some of the examples below. Generally, until you are sure that you're getting exactly the data you're looking for, you should limit the number of observations returned to a sensibe maximum such as 10 or 100 (by setting n to such a value).
Remember, much of the data provided at WRDS is huge! It is highly recommended to develop your code using such an observation limit, then simply remove that limit (by setting n to -1) when you are ready to run your final code. Related to this is the R option max.print, which applies to R no matter how you are running it, be it the WRDS Cloud as an interactive or batch job, or a remote RStudio conncetion. The option max.print dictates how many rows of output a given command is allowed to return before it is truncated. You can view your R session's current max.print value with the command getOptions('max.print'). The default setting is 1000, but it counts every column as its own entry. Thus a query which returns 2000 rows of output but has 5 columns (i.e.
Queries for 5 variables) would print out only 200 lines of that output (as each row essentially 'counts' as 5). You can increase this value with the command options(max.print=1000000), which would raise the limit to 1000000 for example. Keep in mind that the entire result set of your query is still saved in full to the output of dbFetch (the data variable in our examples), the max.print value only limits the cosmetic appearance of printing raw data to your R console (like we do in the third line above to view the contents of data). NOTE: Unlike querying the PostgreSQL informationschema table, querying tables themselves (such as crsp.dsf) does not require that you adhere to any specific case. However, to keep things the same across the board, WRDS recommends always using lowercase for referencing libraries and their datasets.
Querying Data: Searching by Variable. Datasets often contain a large number of variables (column headers) such as date, ticker, cusip, price, or a host of other values depending on dataset. Limiting the number of variables returned in queries makes the resulting data neater and easier to read, but also speeds up the query execution time and makes the resulting size of the returned data smaller. Once we have queried the metadata and understand the available variables, we probably want to specify only those we are interested in. We can do this by specifying each variable to query explicitly in our SELECT statment, instead of selecting all (via the asterisk. which matches all variables). Here is an example where we specify the cusip, permno, date, and two price variables from the CRSP Daily Stock File: res.
Users connecting from a Mac OS X workstation will need Terminal and - Terminal is included with OS X and can be found in /Applications/Utilities/Terminal and XQuartz is available for free online. Once you've installed XQuartz (you may need to restart your computer after installing it), perform the following steps to be connected to the WRDS Cloud with graphics capabilities:. Launch Terminal from /Applications/Utilities/Terminal. SSH to the Wrds Cloud with the following command: ssh -X wrds-cloud.wharton.upenn.edu.
XQuartz will automatically launch. Authenticate in Terminal as normal NOTE: The -X flag in step #2 above is uppercase. Generating a Graph. Once connected with graphical capabilities, graphical R packages can be used within an interactive R session as normal (as if you were running your R session locally on your workstation). The following workflow will generate an example graph of the performance of the Dow Joes Industrial Index over time:. Start an interactive job on the WRDS Cloud: qrsh.
After being assigned to a compute node, start an interactive R session: R. Within the R session, submit your query: res. Using RStudio to graph or plot your data is very similar to the WRDS Cloud method above, except that we don't need to initiate a connection first because we've already set up an.Rprofile file (in the section RStudio: Installing and Preparing Your Environment above).
This example uses the R built-in graphics package, but you could install any package of your own choosing and use that intead. The following workflow will generate an example graph of the performance of the Dow Joes Industrial Index over time:. Launch RStudio, which should automatically connect to WRDS (and give you the connection object wrds). Submit your query: res. WRDS has made many popular statistical R packages available on the WRDS Cloud (almost 10,000 packages at present). To see the list of packages currently installed on the WRDS Cloud, enter installed.packages within an R shell. If you find that you would like to use additional R packages not presently supplied by WRDS, or a different version of one that is installed, you may install your own packages in your home directory and use them in your R programming.
Finalcode R Client For Mac
This section details how to do this. NOTE: These procedures detail installing packages on the WRDS Cloud. If instead you are using RStudio, you can install packages from the Tools menu. Installing R Packages. To install packages on the WRDS Cloud:. WRDS recommends that you set a dedicated directory just for R packages in your home directory at /lib/R.
Download oracle 11g client for mac os x. To accomplish this, first create this directory (that is, make a directory called lib directly in your WRDS Cloud home directory, then create a directory called R inside the lib directory), then add the following line to the end of your.Rprofile file:.libPaths( c(.libPaths, '/lib/R') ) This will append your custom package directory to the list of paths that R searches when you load R libraries. Download the package you want to install to your home directory on the WRDS Cloud. You could use curl, wget, or even scp. The WRDS Cloud does not support directly installing or updating from CRAN from within R, so you will need to first manually download the package you wish to install. Downloading your package must take place on the command line, outside of the R shell; for example, here we download the R package geo to our current working directory: wget Note: If you have already started an interactive session via qrsh, you will not be able to download packages.
Only the WRDS Cloud head nodes may access the greater internet to download or update packages. Logout from your interactive session first to return to a head node (such as wrds-cloud-login2-h), then download your package. Once downloaded, start an interactive job and launch an R shell as described in the WRDS Cloud: Interactive Jobs section of this document. Then run the the install.packages command to install your downloaded package, providing the path to your R lib directory like so: install.packages('/geo1.4-3.tar.gz', lib='/lib/R'). Once the command completes, your package has been installed in the directory you specified. In an interactive R session, or in your next batch R program, load your package with the library command: library(geo) You may then use the featureset of your newly-installed package.
Example Workflow and Sample Programs. There are many ways to perform analytical research against data, but most involve the two-step procedure explored above:.
Examine the metadata to determine what data is available and by what names, then. Contruct a data query to gather precisely the data needed for the research task The following set of R queries represents a sample R workflow using WRDS data, mimicking the workflow of a researcher who might be new to a given data library.
The commands in this workflow could be run interactively, submitted via a batch job (or jobs), or run in RStudio. What data libraries can I work with? Looks like only one of my permnos posted such a high Ask price during this window. I wonder how many other companies have similar Ask histories.
Let's open the search to all permnos that have ever posted an Ask Price over $2,000 in any date range (I use distinct here to only return one entry per matching permno). Since I'm querying against all permnos and the entire date range of the dataset, I'm prepared for this query to take a little longer: res 2000') data. I think I'm starting to get the picture. This is just an example of how one might approach an analytics task in R. It begins by gathering metadata information from the informationschema tables to learn more about the data available - the libraries, datasets, and variables - and then using that information to select meaningful observations from the data itself. A common next step after the above exploration is to then write a batch program that uses the above one-off queries together.
An example might be a program that uses a loop to iterate over each PERMNO that has ever posted an ask price over $2000 and to calculate how long a date range it was able to maintain that height. Or perhaps certain dates were more prolific than others - tallying the number of high asks per date might be informative. Joining Data from Separate Datasets. Data from separate datasets can be joined and analyzed together. In this example, we will join Compustat Fundamentals (i.e. Comp.funda) with pricing data (i.e. Comp.secm), querying for total assets and liabilities mixed with monthly close price and shares outstanding.
The resulting data frame data contains data from both datasets joined by a common gvkey identifier and date. Note that running joins between large sets of data can require vast amounts of memory and execution time. Memory cleaner mac app virus removal.
Be careful to limit the scope of your queries to reasonable sizes when performing joins. This query reports on a single company (IBM) and with a data point frequency of one year, resulting in a result of 55 observations (as of 2017) with a very fast query execution time. NOTE: Your institution would need to subscribe to both datasets for the above to work. Further Reading.
TOKYO, Japan (May 9, 2017)– Digital Arts Inc. (headquartered in Chiyoda-ku, Tokyo, Japan; CEO: Toshio Dogu; “Digital Arts”; Code 2326), a provider of information security software, announced the immediate global availability of FinalCode Client for Mac. Now FinalCode, a persistent, file-centric information rights management (IRM) solution that protects files wherever they go, inside and outside of the organization, is available for both Windows and Mac users. Historically, Microsoft Windows has been the preferred desktop operating system for the enterprise market worldwide, notably in publication, design and music verticals. Today, the popularity of web-based cloud applications and the bring-your-own device (BYOD) movement have opened the enterprise IT environment to different operating systems and devices. As part of this shift, FinalCode has seen a rise in demand for the Mac OS in enterprises of all sizes and in all industry sectors worldwide. Many customers have requested to use FinalCode’s complete file protection on both Windows and Mac against targeted attacks, negligence, and internal fraud.
The new FinalCode Client for Mac released globally offers a complete set of enterprise-grade security features equivalent to the current Windows edition of FinalCode Ver 5. FinalCode Client for Mac responds to needs by domestic Japanese customers using Mac as well as global companies mainly in the US, Europe and Asia.
Support for AutoCAD files on Mac is scheduled for the next FinalCode Client for Mac release. Digital Arts strives to 'make a Made in Japan solution the global standard' and offers FinalCode as the final frontier of file collaboration security for enterprises and government agencies at home and abroad. About FinalCode FinalCode is persistent file security solution that provides password-free automatic file encryption and tracking.
File access is limited to authorized users or groups to stop leaks of sensitive information, even if files are sent to unintentional recipients. It also offers the unique ability to remotely delete and/or change permissions on files already delivered. External users can view FinalCode protected files at no cost. FinalCode realizes borderless control on critical information assets, providing a piece of mind to businesses and organizations exposed to various risks of information loss. About Digital Arts Inc.
Digital Arts, Inc. Is a provider of information security products with a unique patented web filtering technology at its core. It plan, develops, sells and supports internet security products on its own, while also delivering added value as the first Japanese manufacturer to launch a web filtering software in the industry. Digital Arts is highly recognized for its most comprehensive domestic web filtering database and its unique filtering technology patented in 27 countries and regions around the world. Digital Arts has become the top domestic supplier of web filter software i-FILTER (corporate and public-sectors), i-FILTER for Consumer, and i-FILTER Browser & Cloud.
Other product lineup includes m-FILTER, a gateway email security software for corporations, m-FILTER MailAdviser, a client email anti-misdelivery software, D-SPA, a secure proxy appliance solution, and FinalCode, the ultimate password-less file encryption and tracking solution.