# big-o-performance A simple html app to demonstrate performance costs of data structures. - Clone the project - Navigate to the root of the project in a termina or command prompt - Run 'npm install' - Run 'npm start' - Go to the URL specified in the terminal or command prompt to try out the app. # This app was created from the Create React App NPM. Below are instructions from that project. Below you will find some information on how to perform common tasks. You can find the most recent version of this guide [here](https://github.com/facebookincubator/create-react-app/blob/master/template/README.md). ## Table of Contents - [Updating to New Releases](#updating-to-new-releases) - [Sending Feedback](#sending-feedback) - [Folder Structure](#folder-structure) - [Available Scripts](#available-scripts) - [npm start](#npm-start) - [npm run build](#npm-run-build) - [npm run eject](#npm-run-eject) - [Displaying Lint Output in the Editor](#displaying-lint-output-in-the-editor) - [Installing a Dependency](#installing-a-dependency) - [Importing a Component](#importing-a-component) - [Adding a Stylesheet](#adding-a-stylesheet) - [Post-Processing CSS](#post-processing-css) - [Adding Images and Fonts](#adding-images-and-fonts) - [Adding Bootstrap](#adding-bootstrap) - [Adding Flow](#adding-flow) - [Adding Custom Environment Variables](#adding-custom-environment-variables) - [Integrating with a Node Backend](#integrating-with-a-node-backend) - [Proxying API Requests in Development](#proxying-api-requests-in-development) - [Deployment](#deployment) - [Now](#now) - [Heroku](#heroku) - [Surge](#surge) - [GitHub Pages](#github-pages) - [Something Missing?](#something-missing) ## Updating to New Releases Create React App is divided into two packages: * `create-react-app` is a global command-line utility that you use to create new projects. * `react-scripts` is a development dependency in the generated projects (including this one). You almost never need to update `create-react-app` itself: it’s delegates all the setup to `react-scripts`. When you run `create-react-app`, it always creates the project with the latest version of `react-scripts` so you’ll get all the new features and improvements in newly created apps automatically. To update an existing project to a new version of `react-scripts`, [open the changelog](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md), find the version you’re currently on (check `package.json` in this folder if you’re not sure), and apply the migration instructions for the newer versions. In most cases bumping the `react-scripts` version in `package.json` and running `npm install` in this folder should be enough, but it’s good to consult the [changelog](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md) for potential breaking changes. We commit to keeping the breaking changes minimal so you can upgrade `react-scripts` painlessly. ## Sending Feedback We are always open to [your feedback](https://github.com/facebookincubator/create-react-app/issues). ## Folder Structure After creation, your project should look like this: ``` my-app/ README.md index.html favicon.ico node_modules/ package.json src/ App.css App.js index.css index.js logo.svg ``` For the project to build, **these files must exist with exact filenames**: * `index.html` is the page template; * `favicon.ico` is the icon you see in the browser tab; * `src/index.js` is the JavaScript entry point. You can delete or rename the other files. You may create subdirectories inside `src`. For faster rebuilds, only files inside `src` are processed by Webpack. You need to **put any JS and CSS files inside `src`**, or Webpack won’t see them. You can, however, create more top-level directories. They will not be included in the production build so you can use them for things like documentation. ## Available Scripts In the project directory, you can run: ### `npm start` Runs the app in the development mode.<br> Open [http://localhost:3000](http://localhost:3000) to view it in the browser. The page will reload if you make edits.<br> You will also see any lint errors in the console. ### `npm run build` Builds the app for production to the `build` folder.<br> It correctly bundles React in production mode and optimizes the build for the best performance. The build is minified and the filenames include the hashes.<br> Your app is ready to be deployed! ### `npm run eject` **Note: this is a one-way operation. Once you `eject`, you can’t go back!** If you aren’t satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project. Instead, it will copy all the configuration files and the transitive dependencies (Webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own. You don’t have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it. ## Displaying Lint Output in the Editor >Note: this feature is available with `react-scripts@0.2.0` and higher. Some editors, including Sublime Text, Atom, and Visual Studio Code, provide plugins for ESLint. They are not required for linting. You should see the linter output right in your terminal as well as the browser console. However, if you prefer the lint results to appear right in your editor, there are some extra steps you can do. You would need to install an ESLint plugin for your editor first. >**A note for Atom `linter-eslint` users** >If you are using the Atom `linter-eslint` plugin, make sure that **Use global ESLint installation** option is checked: ><img src="http://i.imgur.com/yVNNHJM.png" width="300"> Then make sure `package.json` of your project ends with this block: ```js { // ... "eslintConfig": { "extends": "./node_modules/react-scripts/config/eslint.js" } } ``` Projects generated with `react-scripts@0.2.0` and higher should already have it. If you don’t need ESLint integration with your editor, you can safely delete those three lines from your `package.json`. Finally, you will need to install some packages *globally*: ```sh npm install -g eslint babel-eslint eslint-plugin-react eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-flowtype ``` We recognize that this is suboptimal, but it is currently required due to the way we hide the ESLint dependency. The ESLint team is already [working on a solution to this](https://github.com/eslint/eslint/issues/3458) so this may become unnecessary in a couple of months. ## Installing a Dependency The generated project includes React and ReactDOM as dependencies. It also includes a set of scripts used by Create React App as a development dependency. You may install other dependencies (for example, React Router) with `npm`: ``` npm install --save <library-name> ``` ## Importing a Component This project setup supports ES6 modules thanks to Babel. While you can still use `require()` and `module.exports`, we encourage you to use [`import` and `export`](http://exploringjs.com/es6/ch_modules.html) instead. For example: ### `Button.js` ```js import React, { Component } from 'react'; class Button extends Component { render() { // ... } } export default Button; // Don’t forget to use export default! ``` ### `DangerButton.js` ```js import React, { Component } from 'react'; import Button from './Button'; // Import a component from another file class DangerButton extends Component { render() { return <Button color="red" />; } } export default DangerButton; ``` Be aware of the [difference between default and named exports](http://stackoverflow.com/questions/36795819/react-native-es-6-when-should-i-use-curly-braces-for-import/36796281#36796281). It is a common source of mistakes. We suggest that you stick to using default imports and exports when a module only exports a single thing (for example, a component). That’s what you get when you use `export default Button` and `import Button from './Button'`. Named exports are useful for utility modules that export several functions. A module may have at most one default export and as many named exports as you like. Learn more about ES6 modules: * [When to use the curly braces?](http://stackoverflow.com/questions/36795819/react-native-es-6-when-should-i-use-curly-braces-for-import/36796281#36796281) * [Exploring ES6: Modules](http://exploringjs.com/es6/ch_modules.html) * [Understanding ES6: Modules](https://leanpub.com/understandinges6/read#leanpub-auto-encapsulating-code-with-modules) ## Adding a Stylesheet This project setup uses [Webpack](https://webpack.github.io/) for handling all assets. Webpack offers a custom way of “extending” the concept of `import` beyond JavaScript. To express that a JavaScript file depends on a CSS file, you need to **import the CSS from the JavaScript file**: ### `Button.css` ```css .Button { padding: 20px; } ``` ### `Button.js` ```js import React, { Component } from 'react'; import './Button.css'; // Tell Webpack that Button.js uses these styles class Button extends Component { render() { // You can use them as regular CSS styles return <div className="Button" />; } } ``` **This is not required for React** but many people find this feature convenient. You can read about the benefits of this approach [here](https://medium.com/seek-ui-engineering/block-element-modifying-your-javascript-components-d7f99fcab52b). However you should be aware that this makes your code less portable to other build tools and environments than Webpack. In development, expressing dependencies this way allows your styles to be reloaded on the fly as you edit them. In production, all CSS files will be concatenated into a single minified `.css` file in the build output. If you are concerned about using Webpack-specific semantics, you can put all your CSS right into `src/index.css`. It would still be imported from `src/index.js`, but you could always remove that import if you later migrate to a different build tool. ## Post-Processing CSS This project setup minifies your CSS and adds vendor prefixes to it automatically through [Autoprefixer](https://github.com/postcss/autoprefixer) so you don’t need to worry about it. For example, this: ```css .App { display: flex; flex-direction: row; align-items: center; } ``` becomes this: ```css .App { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-orient: horizontal; -webkit-box-direction: normal; -ms-flex-direction: row; flex-direction: row; -webkit-box-align: center; -ms-flex-align: center; align-items: center; } ``` There is currently no support for preprocessors such as Less, or for sharing variables across CSS files. ## Adding Images and Fonts With Webpack, using static assets like images and fonts works similarly to CSS. You can **`import` an image right in a JavaScript module**. This tells Webpack to include that image in the bundle. Unlike CSS imports, importing an image or a font gives you a string value. This value is the final image path you can reference in your code. Here is an example: ```js import React from 'react'; import logo from './logo.png'; // Tell Webpack this JS file uses this image console.log(logo); // /logo.84287d09.png function Header() { // Import result is the URL of your image return <img src={logo} alt="Logo" />; } export default function Header; ``` This works in CSS too: ```css .Logo { background-image: url(./logo.png); } ``` Webpack finds all relative module references in CSS (they start with `./`) and replaces them with the final paths from the compiled bundle. If you make a typo or accidentally delete an important file, you will see a compilation error, just like when you import a non-existent JavaScript module. The final filenames in the compiled bundle are generated by Webpack from content hashes. If the file content changes in the future, Webpack will give it a different name in production so you don’t need to worry about long-term caching of assets. Please be advised that this is also a custom feature of Webpack. **It is not required for React** but many people enjoy it (and React Native uses a similar mechanism for images). However it may not be portable to some other environments, such as Node.js and Browserify. If you prefer to reference static assets in a more traditional way outside the module system, please let us know [in this issue](https://github.com/facebookincubator/create-react-app/issues/28), and we will consider support for this. ## Adding Bootstrap You don’t have to use [React Bootstrap](https://react-bootstrap.github.io) together with React but it is a popular library for integrating Bootstrap with React apps. If you need it, you can integrate it with Create React App by following these steps: Install React Bootstrap and Bootstrap from NPM. React Bootstrap does not include Bootstrap CSS so this needs to be installed as well: ``` npm install react-bootstrap --save npm install bootstrap@3 --save ``` Import Bootstrap CSS and optionally Bootstrap theme CSS in the ```src/index.js``` file: ```js import 'bootstrap/dist/css/bootstrap.css'; import 'bootstrap/dist/css/bootstrap-theme.css'; ``` Import required React Bootstrap components within ```src/App.js``` file or your custom component files: ```js import { Navbar, Jumbotron, Button } from 'react-bootstrap'; ``` Now you are ready to use the imported React Bootstrap components within your component hierarchy defined in the render method. Here is an example [`App.js`](https://gist.githubusercontent.com/gaearon/85d8c067f6af1e56277c82d19fd4da7b/raw/6158dd991b67284e9fc8d70b9d973efe87659d72/App.js) redone using React Bootstrap. ## Adding Flow Flow typing is currently [not supported out of the box](https://github.com/facebookincubator/create-react-app/issues/72) with the default `.flowconfig` generated by Flow. If you run it, you might get errors like this: ```js node_modules/fbjs/lib/Deferred.js.flow:60 60: Promise.prototype.done.apply(this._promise, arguments); ^^^^ property `done`. Property not found in 495: declare class Promise<+R> { ^ Promise. See lib: /private/tmp/flow/flowlib_34952d31/core.js:495 node_modules/fbjs/lib/shallowEqual.js.flow:29 29: return x !== 0 || 1 / (x: $FlowIssue) === 1 / (y: $FlowIssue); ^^^^^^^^^^ identifier `$FlowIssue`. Could not resolve name src/App.js:3 3: import logo from './logo.svg'; ^^^^^^^^^^^^ ./logo.svg. Required module not found src/App.js:4 4: import './App.css'; ^^^^^^^^^^^ ./App.css. Required module not found src/index.js:5 5: import './index.css'; ^^^^^^^^^^^^^ ./index.css. Required module not found ``` To fix this, change your `.flowconfig` to look like this: ```ini [libs] ./node_modules/fbjs/flow/lib [options] esproposal.class_static_fields=enable esproposal.class_instance_fields=enable module.name_mapper='^\(.*\)\.css$' -> 'react-scripts/config/flow/css' module.name_mapper='^\(.*\)\.\(jpg\|png\|gif\|eot\|otf\|webp\|svg\|ttf\|woff\|woff2\|mp4\|webm\)$' -> 'react-scripts/config/flow/file' suppress_type=$FlowIssue suppress_type=$FlowFixMe ``` Re-run flow, and you shouldn’t get any extra issues. If you later `eject`, you’ll need to replace `react-scripts` references with the `<PROJECT_ROOT>` placeholder, for example: ```ini module.name_mapper='^\(.*\)\.css$' -> '<PROJECT_ROOT>/config/flow/css' module.name_mapper='^\(.*\)\.\(jpg\|png\|gif\|eot\|otf\|webp\|svg\|ttf\|woff\|woff2\|mp4\|webm\)$' -> '<PROJECT_ROOT>/config/flow/file' ``` We will consider integrating more tightly with Flow in the future so that you don’t have to do this. ## Adding Custom Environment Variables >Note: this feature is available with `react-scripts@0.2.3` and higher. Your project can consume variables declared in your environment as if they were declared locally in your JS files. By default you will have `NODE_ENV` defined for you, and any other environment variables starting with `REACT_APP_`. These environment variables will be defined for you on `process.env`. For example, having an environment variable named `REACT_APP_SECRET_CODE` will be exposed in your JS as `process.env.REACT_APP_SECRET_CODE`, in addition to `process.env.NODE_ENV`. These environment variables can be useful for displaying information conditionally based on where the project is deployed or consuming sensitive data that lives outside of version control. First, you need to have environment variables defined, which can vary between OSes. For example, let's say you wanted to consume a secret defined in the environment inside a `<form>`: ```jsx render() { return ( <div> <small>You are running this application in <b>{process.env.NODE_ENV}</b> mode.</small> <form> <input type="hidden" defaultValue={process.env.REACT_APP_SECRET_CODE} /> </form> </div> ); } ``` The above form is looking for a variable called `REACT_APP_SECRET_CODE` from the environment. In order to consume this value, we need to have it defined in the environment: ### Windows (cmd.exe) ```cmd set REACT_APP_SECRET_CODE=abcdef&&npm start ``` (Note: the lack of whitespace is intentional.) ### Linux, OS X (Bash) ```bash REACT_APP_SECRET_CODE=abcdef npm start ``` > Note: Defining environment variables in this manner is temporary for the life of the shell session. Setting permanent environment variables is outside the scope of these docs. With our environment variable defined, we start the app and consume the values. Remember that the `NODE_ENV` variable will be set for you automatically. When you load the app in the browser and inspect the `<input>`, you will see its value set to `abcdef`, and the bold text will show the environment provided when using `npm start`: ```html <div> <small>You are running this application in <b>development</b> mode.</small> <form> <input type="hidden" value="abcdef" /> </form> </div> ``` Having access to the `NODE_ENV` is also useful for performing actions conditionally: ```js if (process.env.NODE_ENV !== 'production') { analytics.disable(); } ``` ## Integrating with a Node Backend Check out [this tutorial](https://www.fullstackreact.com/articles/using-create-react-app-with-a-server/) for instructions on integrating an app with a Node backend running on another port, and using `fetch()` to access it. You can find the companion GitHub repository [here](https://github.com/fullstackreact/food-lookup-demo). ## Proxying API Requests in Development >Note: this feature is available with `react-scripts@0.2.3` and higher. People often serve the front-end React app from the same host and port as their backend implementation. For example, a production setup might look like this after the app is deployed: ``` / - static server returns index.html with React app /todos - static server returns index.html with React app /api/todos - server handles any /api/* requests using the backend implementation ``` Such setup is **not** required. However, if you **do** have a setup like this, it is convenient to write requests like `fetch('/api/todos')` without worrying about redirecting them to another host or port during development. To tell the development server to proxy any unknown requests to your API server in development, add a `proxy` field to your `package.json`, for example: ```js "proxy": "http://localhost:4000", ``` This way, when you `fetch('/api/todos')` in development, the development server will recognize that it’s not a static asset, and will proxy your request to `http://localhost:4000/api/todos` as a fallback. Conveniently, this avoids [CORS issues](http://stackoverflow.com/questions/21854516/understanding-ajax-cors-and-security-considerations) and error messages like this in development: ``` Fetch API cannot load http://localhost:4000/api/todos. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:3000' is therefore not allowed access. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled. ``` Keep in mind that `proxy` only has effect in development (with `npm start`), and it is up to you to ensure that URLs like `/api/todos` point to the right thing in production. You don’t have to use the `/api` prefix. Any unrecognized request will be redirected to the specified `proxy`. Currently the `proxy` option only handles HTTP requests, and it won’t proxy WebSocket connections. If the `proxy` option is **not** flexible enough for you, alternatively you can: * Enable CORS on your server ([here’s how to do it for Express](http://enable-cors.org/server_expressjs.html)). * Use [environment variables](#adding-custom-environment-variables) to inject the right server host and port into your app. ## Deployment By default, Create React App produces a build assuming your app is hosted at the server root. To override this, specify the `homepage` in your `package.json`, for example: ```js "homepage": "http://mywebsite.com/relativepath", ``` This will let Create React App correctly infer the root path to use in the generated HTML file. ### Now See [this example](https://github.com/xkawi/create-react-app-now) for a zero-configuration single-command deployment with [now](https://zeit.co/now). ### Heroku Use the [Heroku Buildpack for Create React App](https://github.com/mars/create-react-app-buildpack). You can find instructions in [Deploying React with Zero Configuration](https://blog.heroku.com/deploying-react-with-zero-configuration). ### Surge Install the Surge CLI if you haven't already by running `npm install -g surge`. Run the `surge` command and log in you or create a new account. You just need to specify the *build* folder and your custom domain, and you are done. ```sh email: email@domain.com password: ******** project path: /path/to/project/build size: 7 files, 1.8 MB domain: create-react-app.surge.sh upload: [====================] 100%, eta: 0.0s propagate on CDN: [====================] 100% plan: Free users: email@domain.com IP Address: X.X.X.X Success! Project is published and running at create-react-app.surge.sh ``` Note that in order to support routers that use html5 `pushState` API, you may want to rename the `index.html` in your build folder to `200.html` before deploying to Surge. This [ensures that every URL falls back to that file](https://surge.sh/help/adding-a-200-page-for-client-side-routing). ### GitHub Pages >Note: this feature is available with `react-scripts@0.2.0` and higher. Open your `package.json` and add a `homepage` field: ```js "homepage": "http://myusername.github.io/my-app", ``` **The above step is important!** Create React App uses the `homepage` field to determine the root URL in the built HTML file. Now, whenever you run `npm run build`, you will see a cheat sheet with a sequence of commands to deploy to GitHub pages: ```sh git commit -am "Save local changes" git checkout -B gh-pages git add -f build git commit -am "Rebuild website" git filter-branch -f --prune-empty --subdirectory-filter build git push -f origin gh-pages git checkout - ``` You may copy and paste them, or put them into a custom shell script. You may also customize them for another hosting provider. Note that GitHub Pages doesn't support routers that use the HTML5 `pushState` history API under the hood (for example, React Router using `browserHistory`). This is because when there is a fresh page load for a url like `http://user.github.io/todomvc/todos/42`, where `/todos/42` is a frontend route, the GitHub Pages server returns 404 because it knows nothing of `/todos/42`. If you want to add a router to a project hosted on GitHub Pages, here are a couple of solutions: * You could switch from using HTML5 history API to routing with hashes. If you use React Router, you can switch to `hashHistory` for this effect, but the URL will be longer and more verbose (for example, `http://user.github.io/todomvc/#/todos/42?_k=yknaj`). [Read more](https://github.com/reactjs/react-router/blob/master/docs/guides/Histories.md#histories) about different history implementations in React Router. * Alternatively, you can use a trick to teach GitHub Pages to handle 404 by redirecting to your `index.html` page with a special redirect parameter. You would need to add a `404.html` file with the redirection code to the `build` folder before deploying your project, and you’ll need to add code handling the redirect parameter to `index.html`. You can find a detailed explanation of this technique [in this guide](https://github.com/rafrex/spa-github-pages). ## Something Missing? If you have ideas for more “How To” recipes that should be on this page, [let us know](https://github.com/facebookincubator/create-react-app/issues) or [contribute some!](https://github.com/facebookincubator/create-react-app/edit/master/template/README.md)

QuranMetaphor: A Multi-Task Framework for Qur'anic Metaphor Analysis This repository is designed to ensure the reproducibility of the experiments presented in the manuscript. It implements the specific hierarchical tasks (Type, Origin, Functional Context) and the Qarīna-Aware Interaction Layer described in the paper. This module is a specialized

SEIS 665 Assignment 2: Linux & Git Overview This week we will focus on becoming familiar with launching a Linux server and working with some basic Linux and Git commands. We will use AWS to launch and host the Linux server. AWS might seem a little confusing at this point. Don’t worry, we will gain much more hands-on experience with AWS throughout the course. The goal is to get you comfortable working with the technology and not overwhelm you with all the details. Requirements You need to have a personal AWS account and GitHub account for this assignment. You should also read the Git Hands-on Guide and Linux Hands-on Guide before beginning this exercise. A word about grading One of the key DevOps practices we learn about in this class is the use of automation to increase the speed and repeatability of processes. Automation is utilized during the assignment grading process to review and assess your work. It’s important that you follow the instructions in each assignment and type in required files and resources with the proper names. All names are case sensitive, so a name like "Web1" is not the same as "web1". If you misspell a name, use the wrong case, or put a file in the wrong directory location you will lose points on your assignment. This is the easiest way to lose points, and also the most preventable. You should always double-check your work to make sure it accurately reflects the requirements specified in the assignment. You should always carefully review the content of your files before submitting your assignment. The assignment Let’s get started! Create GitHub repository The first step in the assignment is to setup a Git repository on GitHub. We will use a special solution called GitHub Classroom for this course which automates the process of setting up student assignment repositories. Here are the basic steps: Click on the following link to open Assignment 2 on the GitHub Classroom site: https://classroom.github.com/a/K4zcVmX- (Links to an external site.)Links to an external site. Click on the Accept this assignment button. GitHub Classroom will provide you with a URL (https) to access the assignment repository. Either copy this address to your clipboard or write it down somewhere. You will need to use this address to set up the repository on a Linux server. Example: https://github.com/UST-SEIS665/hw2-seis665-02-spring2019-<your github id>.git At this point your new repository to ready to use. The repository is currently empty. We will put some content in there soon! Launch Linux server The second step in the assignment is to launch a Linux server using AWS EC2. The server should have the following characteristics: Amazon Linux 2 AMI 64-bit (usually the first option listed) Located in a U.S. region (us-east-1) t2.micro instance type All default instance settings (storage, vpm, security group, etc.) I’ve shown you how to launch EC2 instances in class. You can review it on Canvas. Once you launch the new server, it may take a few minutes to provision. Log into server The next step is to log into the Linux server using a terminal program with a secure shell (SSH) support. You can use iTerm2 (Links to an external site.)Links to an external site. on a Mac and GitBash/PuTTY (Links to an external site.)Links to an external site. on a PC. You will need to have the private server key and the public IP address before attempting to log into the server. The server key is basically your password. If you lose it, you will need to terminate the existing instance and launch a new server. I recommend reusing the same key when launching new servers throughout the class. Note, I make this recommendation to make the learning process easier and not because it is a common security practice. I’ve shown you how to use a terminal application to log into the instance using a Windows desktop. Your personal computer or lab computer may be running a different OS version, but the process is still very similar. You can review the videos on the Canvas. Working with Linux If you’ve made it this far, congratulations! You’ve made it over the toughest hurdle. By the end of this course, I promise you will be able to launch and log into servers in your sleep. You should be looking at a login screen that looks something like this: Last login: Mon Mar 21 21:17:54 2016 from 174-20-199-194.mpls.qwest.net __| __|_ ) _| ( / Amazon Linux AMI ___|\___|___| https://aws.amazon.com/amazon-linux-ami/2015.09-release-notes/ 8 package(s) needed for security, out of 17 available Run "sudo yum update" to apply all updates. ec2-user@ip-172-31-15-26 ~]$ Your terminal cursor is sitting at the shell prompt, waiting for you to type in your first command. Remember the shell? It is a really cool program that lets you start other programs and manage services on the Linux system. The rest of this assignment will be spent working with the shell. Note, when you are asked to type in a command in the steps below, don’t type in the dollar-sign ($) character. This is just meant to represent the command prompt. The actual commands are represented by the characters to the right of the command prompt. Let’s start by asking the shell for some help. Type in: $ help The shell provides you with a list of commands you can run along with possible command options. Next, check out one of the pages in the built-in manual: $ man ls A man page will appear with information on how to use the ls command. This command is used to list the contents of file directories. Either space through the contents of the man page or hit q to exit. Most of the core Linux commands have man pages available. But honestly, some of these man pages are a bit hard to understand. Sometimes your best bet is to search on Google if you are trying to figure out how to use a specific command. When you initially log into Linux, the system places you in your home directory. Each user on the system has a separate home directory. Let’s see where your home directory is located: $ pwd The response should be /home/ec2-user. The pwd command is handy to remember if you ever forget what file directory you are currently located in. If you recall from the Linux Hands-on Guide, this directory is also your current working directory. Type in: $ cd / The cd command let’s you change to a new working directory on the server. In this case, we changed to the root (/) directory. This is the parent of all the other directories on the file system. Type in: $ ls The ls command lists the contents of the current directory. As you can see, root directory contains many other directories. You will become familiar with these directories over time. The ls command provides a very basic directory listing. You need to supply the command with some options if you want to see more detailed information. Type in: $ ls -la See how this command provides you with much more detailed information about the files and directories? You can use this detailed listing to see the owner, group, and access control list settings for each file or directory. Do you see any files listed? Remember, the first character in the access control list column denotes whether a listed item is a file or a directory. You probably see a couple files with names like .autofsck. How come you didn’t see this file when you typed in the lscommand without any options? (Try to run this command again to convince yourself.) Files names that start with a period are called hidden files. These files won’t appear on normal directory listings. Type in: $ cd /var Then, type in: $ ls You will see a directory listing for the /var directory. Next, type in: $ ls .. Huh. This directory listing looks the same as the earlier root directory listing. When you use two periods (..) in a directory path that means you are referring to the parent directory of the current directory. Just think of the two dots as meaning the directory above the current directory. Now, type in: $ cd ~ $ pwd Whoa. We’re back at our home directory again. The tilde character (~) is another one of those handy little directory path shortcuts. It always refers to our personal home directory. Keep in mind that since every user has their own home directory, the tilde shortcut will refer to a unique directory for each logged-in user. Most students are used to navigating a file system by clicking a mouse in nested graphical folders. When they start using a command-line to navigate a file system, they sometimes get confused and lose track of their current position in the file system. Remember, you can always use the pwd command to quickly figure out what directory you are currently working in. Let’s make some changes to the file system. We can easily make our own directories on the file system. Type: mkdir test Now type: ls Cool, there’s our new test directory. Let’s pretend we don’t like that directory name and delete it. Type: rmdir test Now it’s gone. How can you be sure? You should know how to check to see if the directory still exists at this point. Go ahead and check. Let’s create another directory. Type in: $ mkdir documents Next, change to the new directory: $ cd documents Did you notice that your command prompt displays the name of the current directory? Something like: [ec2-user@ip-172-31-15-26 documents]$. Pretty handy, huh? Okay, let’s create our first file in the documents directory. This is just an empty file for training purposes. Type in: $ touch paper.txt Check to see that the new file is in the directory. Now, go back to the previous directory. Remember the double dot shortcut? $ cd .. Okay, we don’t like our documents directory any more. Let’s blow it away. Type in: $ rmdir documents Uh oh. The shell didn’t like that command because the directory isn’t empty. Let’s change back into the documents directory. But this time don’t type in the full name of the directory. You can let shell auto-completion do the typing for you. Type in the first couple characters of the directory name and then hit the tab key: $ cd doc<tab> You should use the tab auto-completion feature often. It saves typing and makes working with the Linux file system much much easier. Tab is your friend. Now, remove the file by typing: $ rm paper.txt Did you try to use the tab key instead of typing in the whole file name? Check to make sure the file was deleted from the directory. Next, create a new file: $ touch file1 We like file1 so much that we want to make a backup copy. Type: $ cp file1 file1-backup Check to make sure the new backup copy was created. We don’t really like the name of that new file, so let’s rename it. Type: $ mv file1-backup backup Moving a file to the same directory and giving it a new name is basically the same thing as renaming it. We could have moved it to a different directory if we wanted. Let’s list all of the files in the current directory that start with the letter f: $ ls f* Using wildcard pattern matching in file commands is really useful if you want the command to impact or filter a group of files. Now, go up one directory to the parent directory (remember the double dot shortcut?) We tried to remove the documents directory earlier when it had files in it. Obviously that won’t work again. However, we can use a more powerful command to destroy the directory and vanquish its contents. Behold, the all powerful remove command: $ rm -fr documents Did you remember to use auto-completion when typing in documents? This command and set of options forcibly removes the directory and its contents. It’s a dangerous command wielded by the mightiest Linux wizards. Okay, maybe that’s a bit of an exaggeration. Just be careful with it. Check to make sure the documents directory is gone before proceeding. Let’s continue. Change to the directory /var and make a directory called test. Ugh. Permission denied. We created this darn Linux server and we paid for it. Shouldn’t we be able to do anything we want on it? You logged into the system as a user called ec2-user. While this user can create and manage files in its home directory, it cannot change files all across the system. At least it can’t as a normal user. The ec2-user is a member of the root group, so it can escalate its privileges to super-user status when necessary. Let’s try it: $ sudo mkdir test Check to make sure the directory exists now. Using sudo we can execute commands as a super-user. We can do anything we want now that we know this powerful new command. Go ahead and delete the test directory. Did you remember to use sudo before the rmdir command? Check to make sure the directory is gone. You might be asking yourself the question: why can we list the contents of the /var directory but not make changes? That’s because all users have read access to the /var directory and the ls command is a read function. Only the root users or those acting as a super-user can write changes to the directory. Let’s go back to our home directory: $ cd ~ Editing text files is a really common task on Linux systems because many of the application configuration files are text files. We can create a text file by using a text editor. Type in: $ nano myfile.conf The shell starts up the nano text editor and places your terminal cursor in the editing screen. Nano is a simple text-based word processor. Type in a few lines of text. When you’re done writing your novel, hit ctrl-x and answer y to the prompt to save your work. Finally, hit enter to save the text to the filename you specified. Check to see that your file was saved in the directory. You can take a look at the contents of your file by typing: $ cat myfile.conf The cat command displays your text file content on the terminal screen. This command works fine for displaying small text files. But if your file is hundreds of lines long, the content will scroll down your terminal screen so fast that you won’t be able to easily read it. There’s a better way to view larger text files. Type in: $ less myfile.conf The less command will page the display of a text file, allowing you to page through the contents of the file using the space bar. Your text file is probably too short to see the paging in action though. Hit q to quit out of the less text viewer. Hit the up-arrow key on your keyboard a few times until the commmand nano myfile.conf appears next to your command prompt. Cool, huh? The up-arrow key allows you to replay a previously run command. Linux maintains a list of all the commands you have run since you logged into the server. This is called the command history. It’s a really useful feature if you have to re-run a complex command again. Now, hit ctrl-c. This cancels whatever command is displayed on the command line. Type in the following command to create a couple empty files in the directory: $ touch file1 file2 file3 Confirm that the files were created. Some commands, like touch. allow you to specify multiple files as arguments. You will find that Linux commands have all kinds of ways to make tasks more efficient like this. Throughout this assignment, we have been running commands and viewing results on the terminal screen. The screen is the standard place for commands to output results. It’s known as the standard out (stdout). However, it’s really useful to output results to the file system sometimes. Type in: $ ls > listing.txt Take a look at the directory listing now. You just created a new file. View the contents of the listing.txt file. What do you see? Instead of sending the output from the ls command to the screen we sent it to a text file. Let’s try another one. Type: $ cat myfile.conf > listing.txt Take a look at the contents of the listing.txt file again. It looks like your myfile.conf file now. It’s like you made a copy of it. But what happened to the previous content in the listing.txt file? When you redirect the output of a command using the right angle-bracket character (>), the output overwrites the existing file. Type this command in: $ cat myfile.conf >> listing.txt Now look at the contents of the listing.txt file. You should see your original content displayed twice. When you use two angle-bracket characters in the commmand the output appends (or adds to) the file instead of overwriting it. We redirected the output from a command to a text file. It’s also possible to redirect the input to a command. Typically we use a keyboard to provide input, but sometimes it makes more sense to input a file to a command. For example, how many words are in your new listing.txt file? Let’s find out. Type in: $ wc -w < listing.txt Did you get a number? This command inputs the listing.txt file into a word count program called wc. Type in the command: $ ls /usr/bin The terminal screen probably scrolled quickly as filenames flashed by. The /usr/bin directory holds quite a few files. It would be nice if we could page through the contents of this directory. Well, we can. We can use a special shell feature called pipes. In previous steps, we redirected I/O using the file system. Pipes allow us to redirect I/O between programs. We can redirect the output from one program into another. Type in: $ ls /usr/bin | less Now the directory listing is paged. Hit the spacebar to page through the listing. The pipe, represented by a vertical bar character (|), takes the output from the ls command and redirects it to the less command where the resulting output is paged. Pipes are super powerful and used all the time by savvy Linux operators. Hit the q key to quit the paginated directory listing command. Working with shell scripts Now things are going to get interesting. We’ve been manually typing in commands throughout this exercise. If we were running a set of repetitive tasks, we would want to automate the process as much as possible. The shell makes it really easy to automate tasks using shell scripts. The shell provides many of the same features as a basic procedural programming language. Let’s write some code. Type in this command: $ j=123 $ echo $j We just created a variable named j referencing the string 123. The echo command printed out the value of the variable. We had to use a dollar sign ($) when referencing the variable in another command. Next, type in: $ j=1+1 $ echo $j Is that what you expected? The shell just interprets the variable value as a string. It’s not going to do any sort of computation. Typing in shell script commands on the command line is sort of pointless. We want to be able to create scripts that we can run over-and-over. Let’s create our first shell script. Use the nano editor to create a file named myscript. When the file is open in the editor, type in the following lines of code: #!/bin/bash echo Hello $1 Now quit the editor and save your file. We can run our script by typing: $ ./myscript World Er, what happened? Permission denied. Didn’t we create this file? Why can’t we run it? We can’t run the script file because we haven’t set the execute permission on the file. Type in: $ chmod u+x myscript This modifies the file access control list to allow the owner of the file to execute it. Let’s try to run the command again. Hit the up-arrow key a couple times until the ./myscript World command is displayed and hit enter. Hooray! Our first shell script. It’s probably a bit underwhelming. No problem, we’ll make it a little more complex. The script took a single argument called World. Any arguments provided to a shell script are represented as consecutively numbered variables inside the script ($1, $2, etc). Pretty simple. You might be wondering why we had to type the ./ characters before the name of our script file. Try to type in the command without them: $ myscript World Command not found. That seems a little weird. Aren’t we currently in the directory where the shell script is located? Well, that’s just not how the shell works. When you enter a command into the shell, it looks for the command in a predefined set of directories on the server called your PATH. Since your script file isn’t in your special path, the shell reports it as not found. By typing in the ./ characters before the command name you are basically forcing the shell to look for your script in the current directory instead of the default path. Create another file called cleanup using nano. In the file editor window type: #!/bin/bash # My cleanup script mkdir archive mv file* archive Exit the editor window and save the file. Change the permissions on the script file so that you can execute it. Now run the command: $ ./cleanup Take a look at the file directory listing. Notice the archive directory? List the contents of that directory. The script automatically created a new directory and moved three files into it. Anything you can do manually at a command prompt can be automated using a shell script. Let’s create one more shell script. Use nano to create a script called namelist. Here is the content of the script: #!/bin/bash # for-loop test script names='Jason John Jane' for i in $names do echo Hello $i done Change the permissions on the script file so that you can execute it. Run the command: $ ./namelist The script will loop through a set of names stored in a variable displaying each one. Scripts support several programming constructs like for-loops, do-while loops, and if-then-else. These building blocks allow you to create fairly complex scripts for automating tasks. Installing packages and services We’re nearing the end of this assignment. But before we finish, let’s install some new software packages on our server. The first thing we should do is make sure all the current packages installed on our Linux server are up-to-date. Type in: $ sudo yum update -y This is one of those really powerful commands that requires sudo access. The system will review the currently installed packages and go out to the Internet and download appropriate updates. Next, let’s install an Apache web server on our system. Type in: $ sudo yum install httpd -y Bam! You probably never knew that installing a web server was so easy. We’re not going to actually use the web server in this exercise, but we will in future assignments. We installed the web server, but is it actually running? Let’s check. Type in: $ sudo service httpd status Nope. Let’s start it. Type: $ sudo service httpd start We can use the service command to control the services running on the system. Let’s setup the service so that it automatically starts when the system boots up. Type in: $ sudo chkconfig httpd on Cool. We installed the Apache web server on our system, but what other programs are currently running? We can use the pscommand to find out. Type in: $ ps -ax Lots of processes are running on our system. We can even look at the overall performance of our system using the topcommand. Let’s try that now. Type in: $ top The display might seem a little overwhelming at first. You should see lots of performance information displayed including the cpu usage, free memory, and a list of running tasks. We’re almost across the finish line. Let’s make sure all of our valuable work is stored in a git repository. First, we need to install git. Type in the command: $ sudo yum install git -y Check your work It’s very important to check your work before submitting it for grading. A misspelled, misplaced or missing file will cost you points. This may seem harsh, but the reality is that these sorts of mistakes have consequences in the real world. For example, a server instance could fail to launch properly and impact customers because a single required file is missing. Here is what the contents of your git repository should look like before final submission: ┣archive ┃ ┣ file1 ┃ ┣ file2 ┃ ┗ file3 ┣ namelist ┗ myfile.conf Saving our work in the git repository Next, make sure you are still in your home directory (/home/ec2-user). We will install the git repository you created at the beginning of this exercise. You will need to modify this command by typing in the GitHub repository URL you copied earlier. $ git clone <your GitHub URL here>.git Example: git clone https://github.com/UST-SEIS665/hw2-seis665-02-spring2019-<your github id>.git The git application will ask you for your GitHub username and password. Note, if you have multi-factor authentication enabled on your GitHub account you will need to provide a personal token instead of your password. Git will clone (copy) the repository from GitHub to your Linux server. Since the repository is empty the clone happens almost instantly. Check to make sure that a sub-directory called "hw2-seis665-02-spring2019-<username>" exists in the current directory (where <username> is your GitHub account name). Git automatically created this directory as part of the cloning process. Change to the hw2-seis665-02-spring2019-<username> directory and type: $ ls -la Notice the .git hidden directory? This is where git actually stores all of the file changes in your repository. Nothing is actually in your repository yet. Change back to the parent directory (cd ..). Next, let’s move some of our files into the repository. Type: $ mv archive hw2-seis665-02-spring2019-<username> $ mv namelist hw2-seis665-02-spring2019-<username> $ mv myfile.conf hw2-seis665-02-spring2019-<username> Hopefully, you remembered to use the auto-complete function to reduce some of that typing. Change to the hw2-seis665-02-spring2019-<username> directory and list the directory contents. Your files are in the working directory, but are not actually stored in the repository because they haven’t been committed yet. Type in: $ git status You should see a list of untracked files. Let’s tell git that we want these files tracked. Type in: $ git add * Now type in the git status command again. Notice how all the files are now being tracked and are ready to be committed. These files are in the git staging area. We’ll commit them to the repository next. Type: $ git commit -m 'assignment 2 files' Next, take a look at the commit log. Type: $ git log You should see your commit listed along with an assigned hash (long string of random-looking characters). Finally, let’s save the repository to our GitHub account. Type in: $ git push origin master The git client will ask you for your GitHub username and password before pushing the repository. Go back to the GitHub.com website and login if you have been logged out. Click on the repository link for the assignment. Do you see your files listed there? Congratulations, you completed the exercise! Terminate server The last step is to terminate your Linux instance. AWS will bill you for every hour the instance is running. The cost is nominal, but there’s no need to rack up unnecessary charges. Here are the steps to terminate your instance: Log into your AWS account and click on the EC2 dashboard. Click the Instances menu item. Select your server in the instances table. Click on the Actions drop down menu above the instances table. Select the Instance State menu option Click on the Terminate action. Your Linux instance will shutdown and disappear in a few minutes. The EC2 dashboard will continue to display the instance on your instance listing for another day or so. However, the state of the instance will be terminated. Submitting your assignment — IMPORTANT! If you haven’t already, please e-mail me your GitHub username in order to receive credit for this assignment. There is no need to email me to tell me that you have committed your work to GitHub or to ask me if your GitHub submission worked. If you can see your work in your GitHub repository, I can see your work.

There are many good resources for learning Git. (Here's an excellent online book, and this is my videos series introducing Git and GitHub.) But once you've learned the basics, it can be hard to remember which commands to use to execute the most common tasks. I went searching for a Git reference guide that would be useful for beginners like myself, but didn't find anything ideal: Git - the simple guide is useful as a high-level overview of the basic commands, but doesn't provide enough details. Git Cheatsheet uses a nice interactive approach to summarize a ton of git commands on one screen, but it doesn't give you any sense of workflow. Git Reference is close to what I was looking for, and links each entry to the relevant section of Pro Git (awesome!), but is too long for a quick reference. So, I decided to make my own reference guide! The guide below is organized by task, with an emphasis on basic tasks and common command line arguments. It begins with the workflow for cloning, updating, and syncing with a remote repo because that's a common way to get started with Git and GitHub. Note that this is only a reference guide, and will not teach you Git. It does not explain the difference between staged and committed, what to do with a .gitignore file, or when to create a branch. But if you are already familiar with those concepts, this guide will hopefully refresh your memory and help you to discover other commands you might need. Please enjoy, and let me know your thoughts or questions in the comments! Cloning a remote repo (that you created or forked on GitHub) git clone < your-repo-URL >: copies your remote repo to your local machine (in a subdirectory with the repo's name), and automatically creates an "origin" handle git remote add upstream < forked-repo-URL >: adds an "upstream" handle for the repo you forked git remote -v: shows the handles for your remotes git remote show < handlename >: inspect a remote in detail Tracking, committing, and pushing your changes git add < name >: if untracked, start tracking a file or directory; if tracked and modified, stage it for committing git reset HEAD < name >: unstage a changed file git commit -m "message": commits everything that has been staged with a message -a -m "message": automatically stages any modified files, then commits --amend -m "new message": fixes the message from the last commit git push origin master: pushes your commits to the master branch of the origin Syncing your local repo with the upstream repo git fetch upstream: fetch the upstream and store its master branch in "upstream/master" git merge upstream/master: merge that branch into the working branch Viewing the status of your files git status: check which files have been modified and/or staged since the last commit git diff: shows the diff for files that are modified but not staged --staged: shows the diff for files that are staged but not committed Viewing the commit history git log: shows the detailed commit history -1: only shows the last 1 commit -p: shows the line diff for each commit -p --word-diff: shows the word diff for each commit --stat: shows stats instead of diff details --name-status: shows a simpler version of stat --oneline: just shows commit comments gitk: open a visual commit browser Managing branches git branch: shows a list of local branches < branchname >: create a new branch with that name -d < branchname >: delete a branch -v: show the last commit on each local branch -a: show local and remote branches -va: show the last commit on each local and remote branch --merged: list which branches are already merged into the working branch (safe to delete) --no-merged: list which branches are not merged into the working branch git checkout < branchname >: switch the HEAD pointer to a different branch -b < branchname >: create a new branch and switch to it Removing, deleting, and reverting files git rm < name >: deletes that file from the disk, then stages its deletion --cached < name >: stops tracking a file, then stages its deletion (but does not delete it from the disk) git mv < oldname > < newname >: renames the file on disk, then stages the deletion of the old name and addition of the new name git checkout -- < name >: revert a modified file on disk back to the last committed version Other basic commands git init: initialize Git in an existing directory git config --list: shows your Git configuration touch .gitignore: create an empty .gitignore file

<!DOCTYPE html> <html lang="en"> <head> <title>Bitbucket</title> <meta id="bb-bootstrap" data-current-user="{"isKbdShortcutsEnabled": true, "isSshEnabled": false, "isAuthenticated": false}" /> <meta name="frontbucket-version" content="production"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <script nonce="xxI7cPsOVRt9B81s" type="text/javascript">(window.NREUM||(NREUM={})).loader_config={licenseKey:"a2cef8c3d3",applicationID:"548124220"};window.NREUM||(NREUM={}),__nr_require=function(e,t,n){function r(n){if(!t[n]){var i=t[n]={exports:{}};e[n][0].call(i.exports,function(t){var i=e[n][1][t];return r(i||t)},i,i.exports)}return t[n].exports}if("function"==typeof __nr_require)return __nr_require;for(var i=0;i<n.length;i++)r(n[i]);return r}({1:[function(e,t,n){function r(){}function i(e,t,n){return function(){return o(e,[u.now()].concat(c(arguments)),t?null:this,n),t?void 0:this}}var o=e("handle"),a=e(7),c=e(8),f=e("ee").get("tracer"),u=e("loader"),s=NREUM;"undefined"==typeof window.newrelic&&(newrelic=s);var d=["setPageViewName","setCustomAttribute","setErrorHandler","finished","addToTrace","inlineHit","addRelease"],p="api-",l=p+"ixn-";a(d,function(e,t){s[t]=i(p+t,!0,"api")}),s.addPageAction=i(p+"addPageAction",!0),s.setCurrentRouteName=i(p+"routeName",!0),t.exports=newrelic,s.interaction=function(){return(new r).get()};var m=r.prototype={createTracer:function(e,t){var n={},r=this,i="function"==typeof t;return o(l+"tracer",[u.now(),e,n],r),function(){if(f.emit((i?"":"no-")+"fn-start",[u.now(),r,i],n),i)try{return t.apply(this,arguments)}catch(e){throw f.emit("fn-err",[arguments,this,e],n),e}finally{f.emit("fn-end",[u.now()],n)}}}};a("actionText,setName,setAttribute,save,ignore,onEnd,getContext,end,get".split(","),function(e,t){m[t]=i(l+t)}),newrelic.noticeError=function(e,t){"string"==typeof e&&(e=new Error(e)),o("err",[e,u.now(),!1,t])}},{}],2:[function(e,t,n){function r(){return c.exists&&performance.now?Math.round(performance.now()):(o=Math.max((new Date).getTime(),o))-a}function i(){return o}var o=(new Date).getTime(),a=o,c=e(9);t.exports=r,t.exports.offset=a,t.exports.getLastTimestamp=i},{}],3:[function(e,t,n){function r(e){return!(!e||!e.protocol||"file:"===e.protocol)}t.exports=r},{}],4:[function(e,t,n){function r(e,t){var n=e.getEntries();n.forEach(function(e){"first-paint"===e.name?d("timing",["fp",Math.floor(e.startTime)]):"first-contentful-paint"===e.name&&d("timing",["fcp",Math.floor(e.startTime)])})}function i(e,t){var n=e.getEntries();n.length>0&&d("lcp",[n[n.length-1]])}function o(e){e.getEntries().forEach(function(e){e.hadRecentInput||d("cls",[e])})}function a(e){if(e instanceof m&&!g){var t=Math.round(e.timeStamp),n={type:e.type};t<=p.now()?n.fid=p.now()-t:t>p.offset&&t<=Date.now()?(t-=p.offset,n.fid=p.now()-t):t=p.now(),g=!0,d("timing",["fi",t,n])}}function c(e){d("pageHide",[p.now(),e])}if(!("init"in NREUM&&"page_view_timing"in NREUM.init&&"enabled"in NREUM.init.page_view_timing&&NREUM.init.page_view_timing.enabled===!1)){var f,u,s,d=e("handle"),p=e("loader"),l=e(6),m=NREUM.o.EV;if("PerformanceObserver"in window&&"function"==typeof window.PerformanceObserver){f=new PerformanceObserver(r);try{f.observe({entryTypes:["paint"]})}catch(v){}u=new PerformanceObserver(i);try{u.observe({entryTypes:["largest-contentful-paint"]})}catch(v){}s=new PerformanceObserver(o);try{s.observe({type:"layout-shift",buffered:!0})}catch(v){}}if("addEventListener"in document){var g=!1,w=["click","keydown","mousedown","pointerdown","touchstart"];w.forEach(function(e){document.addEventListener(e,a,!1)})}l(c)}},{}],5:[function(e,t,n){function r(e,t){if(!i)return!1;if(e!==i)return!1;if(!t)return!0;if(!o)return!1;for(var n=o.split("."),r=t.split("."),a=0;a<r.length;a++)if(r[a]!==n[a])return!1;return!0}var i=null,o=null,a=/Version\/(\S+)\s+Safari/;if(navigator.userAgent){var c=navigator.userAgent,f=c.match(a);f&&c.indexOf("Chrome")===-1&&c.indexOf("Chromium")===-1&&(i="Safari",o=f[1])}t.exports={agent:i,version:o,match:r}},{}],6:[function(e,t,n){function r(e){function t(){e(a&&document[a]?document[a]:document[i]?"hidden":"visible")}"addEventListener"in document&&o&&document.addEventListener(o,t,!1)}t.exports=r;var i,o,a;"undefined"!=typeof document.hidden?(i="hidden",o="visibilitychange",a="visibilityState"):"undefined"!=typeof document.msHidden?(i="msHidden",o="msvisibilitychange"):"undefined"!=typeof document.webkitHidden&&(i="webkitHidden",o="webkitvisibilitychange",a="webkitVisibilityState")},{}],7:[function(e,t,n){function r(e,t){var n=[],r="",o=0;for(r in e)i.call(e,r)&&(n[o]=t(r,e[r]),o+=1);return n}var i=Object.prototype.hasOwnProperty;t.exports=r},{}],8:[function(e,t,n){function r(e,t,n){t||(t=0),"undefined"==typeof n&&(n=e?e.length:0);for(var r=-1,i=n-t||0,o=Array(i<0?0:i);++r<i;)o[r]=e[t+r];return o}t.exports=r},{}],9:[function(e,t,n){t.exports={exists:"undefined"!=typeof window.performance&&window.performance.timing&&"undefined"!=typeof window.performance.timing.navigationStart}},{}],ee:[function(e,t,n){function r(){}function i(e){function t(e){return e&&e instanceof r?e:e?u(e,f,a):a()}function n(n,r,i,o,a){if(a!==!1&&(a=!0),!l.aborted||o){e&&a&&e(n,r,i);for(var c=t(i),f=v(n),u=f.length,s=0;s<u;s++)f[s].apply(c,r);var p=d[h[n]];return p&&p.push([b,n,r,c]),c}}function o(e,t){y[e]=v(e).concat(t)}function m(e,t){var n=y[e];if(n)for(var r=0;r<n.length;r++)n[r]===t&&n.splice(r,1)}function v(e){return y[e]||[]}function g(e){return p[e]=p[e]||i(n)}function w(e,t){s(e,function(e,n){t=t||"feature",h[n]=t,t in d||(d[t]=[])})}var y={},h={},b={on:o,addEventListener:o,removeEventListener:m,emit:n,get:g,listeners:v,context:t,buffer:w,abort:c,aborted:!1};return b}function o(e){return u(e,f,a)}function a(){return new r}function c(){(d.api||d.feature)&&(l.aborted=!0,d=l.backlog={})}var f="nr@context",u=e("gos"),s=e(7),d={},p={},l=t.exports=i();t.exports.getOrSetContext=o,l.backlog=d},{}],gos:[function(e,t,n){function r(e,t,n){if(i.call(e,t))return e[t];var r=n();if(Object.defineProperty&&Object.keys)try{return Object.defineProperty(e,t,{value:r,writable:!0,enumerable:!1}),r}catch(o){}return e[t]=r,r}var i=Object.prototype.hasOwnProperty;t.exports=r},{}],handle:[function(e,t,n){function r(e,t,n,r){i.buffer([e],r),i.emit(e,t,n)}var i=e("ee").get("handle");t.exports=r,r.ee=i},{}],id:[function(e,t,n){function r(e){var t=typeof e;return!e||"object"!==t&&"function"!==t?-1:e===window?0:a(e,o,function(){return i++})}var i=1,o="nr@id",a=e("gos");t.exports=r},{}],loader:[function(e,t,n){function r(){if(!E++){var e=x.info=NREUM.info,t=l.getElementsByTagName("script")[0];if(setTimeout(u.abort,3e4),!(e&&e.licenseKey&&e.applicationID&&t))return u.abort();f(h,function(t,n){e[t]||(e[t]=n)});var n=a();c("mark",["onload",n+x.offset],null,"api"),c("timing",["load",n]);var r=l.createElement("script");r.src="https://"+e.agent,t.parentNode.insertBefore(r,t)}}function i(){"complete"===l.readyState&&o()}function o(){c("mark",["domContent",a()+x.offset],null,"api")}var a=e(2),c=e("handle"),f=e(7),u=e("ee"),s=e(5),d=e(3),p=window,l=p.document,m="addEventListener",v="attachEvent",g=p.XMLHttpRequest,w=g&&g.prototype;if(d(p.location)){NREUM.o={ST:setTimeout,SI:p.setImmediate,CT:clearTimeout,XHR:g,REQ:p.Request,EV:p.Event,PR:p.Promise,MO:p.MutationObserver};var y=""+location,h={beacon:"bam.nr-data.net",errorBeacon:"bam.nr-data.net",agent:"js-agent.newrelic.com/nr-1208.min.js"},b=g&&w&&w[m]&&!/CriOS/.test(navigator.userAgent),x=t.exports={offset:a.getLastTimestamp(),now:a,origin:y,features:{},xhrWrappable:b,userAgent:s};e(1),e(4),l[m]?(l[m]("DOMContentLoaded",o,!1),p[m]("load",r,!1)):(l[v]("onreadystatechange",i),p[v]("onload",r)),c("mark",["firstbyte",a.getLastTimestamp()],null,"api");var E=0}},{}],"wrap-function":[function(e,t,n){function r(e,t){function n(t,n,r,f,u){function nrWrapper(){var o,a,s,p;try{a=this,o=d(arguments),s="function"==typeof r?r(o,a):r||{}}catch(l){i([l,"",[o,a,f],s],e)}c(n+"start",[o,a,f],s,u);try{return p=t.apply(a,o)}catch(m){throw c(n+"err",[o,a,m],s,u),m}finally{c(n+"end",[o,a,p],s,u)}}return a(t)?t:(n||(n=""),nrWrapper[p]=t,o(t,nrWrapper,e),nrWrapper)}function r(e,t,r,i,o){r||(r="");var c,f,u,s="-"===r.charAt(0);for(u=0;u<t.length;u++)f=t[u],c=e[f],a(c)||(e[f]=n(c,s?f+r:r,i,f,o))}function c(n,r,o,a){if(!m||t){var c=m;m=!0;try{e.emit(n,r,o,t,a)}catch(f){i([f,n,r,o],e)}m=c}}return e||(e=s),n.inPlace=r,n.flag=p,n}function i(e,t){t||(t=s);try{t.emit("internal-error",e)}catch(n){}}function o(e,t,n){if(Object.defineProperty&&Object.keys)try{var r=Object.keys(e);return r.forEach(function(n){Object.defineProperty(t,n,{get:function(){return e[n]},set:function(t){return e[n]=t,t}})}),t}catch(o){i([o],n)}for(var a in e)l.call(e,a)&&(t[a]=e[a]);return t}function a(e){return!(e&&e instanceof Function&&e.apply&&!e[p])}function c(e,t){var n=t(e);return n[p]=e,o(e,n,s),n}function f(e,t,n){var r=e[t];e[t]=c(r,n)}function u(){for(var e=arguments.length,t=new Array(e),n=0;n<e;++n)t[n]=arguments[n];return t}var s=e("ee"),d=e(8),p="nr@original",l=Object.prototype.hasOwnProperty,m=!1;t.exports=r,t.exports.wrapFunction=c,t.exports.wrapInPlace=f,t.exports.argsToArray=u},{}]},{},["loader"]);</script> <meta name="bb-env" content="production" /> <meta id="bb-canon-url" name="bb-canon-url" content="https://bitbucket.org"> <meta name="bb-api-canon-url" content="https://api.bitbucket.org"> <meta name="bitbucket-commit-hash" content="10b0d91b991b"> <meta name="bb-app-node" content="app-3001"> <meta name="bb-dce-env" content="ASH2"> <meta name="bb-view-name" content="bitbucket.apps.repo2.views.SourceView"> <meta name="ignore-whitespace" content="False"> <meta name="tab-size" content="None"> <meta name="locale" content="en"> <meta name="application-name" content="Bitbucket"> <meta name="apple-mobile-web-app-title" content="Bitbucket"> <meta name="slack-app-id" content="A8W8QLZD1"> <meta name="statuspage-api-host" content="https://bqlf8qjztdtr.statuspage.io"> <meta name="theme-color" content="#0049B0"> <meta name="msapplication-TileColor" content="#0052CC"> <meta name="msapplication-TileImage" content="https://d301sr5gafysq2.cloudfront.net/10b0d91b991b/img/logos/bitbucket/mstile-150x150.png"> <link rel="apple-touch-icon" sizes="180x180" type="image/png" href="https://d301sr5gafysq2.cloudfront.net/10b0d91b991b/img/logos/bitbucket/apple-touch-icon.png"> <link rel="icon" sizes="192x192" type="image/png" href="https://d301sr5gafysq2.cloudfront.net/10b0d91b991b/img/logos/bitbucket/android-chrome-192x192.png"> <link rel="icon" sizes="16x16 24x24 32x32 64x64" type="image/x-icon" href="/favicon.ico?v=2"> <link rel="mask-icon" href="https://d301sr5gafysq2.cloudfront.net/10b0d91b991b/img/logos/bitbucket/safari-pinned-tab.svg" color="#0052CC"> <link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="Bitbucket"> <meta name="description" content=""> <meta name="bb-single-page-app" content="true"> <link rel="stylesheet" href="https://d301sr5gafysq2.cloudfront.net/frontbucket/assets/present/vendor.f4e8952a.css"> <script nonce="xxI7cPsOVRt9B81s"> if (window.performance) { window.performance.okayToSendMetrics = !document.hidden && 'onvisibilitychange' in document; if (window.performance.okayToSendMetrics) { window.addEventListener('visibilitychange', function () { if (document.hidden) { window.performance.okayToSendMetrics = false; } }); } } </script> </head> <body> <div id="root"> <script nonce="xxI7cPsOVRt9B81s"> window.__webpack_public_path__ = "https://d301sr5gafysq2.cloudfront.net/frontbucket/assets/present/"; </script> </div> <script nonce="xxI7cPsOVRt9B81s"> window.__sentry__ = {"dsn": "https://2dcda83904474d8c86928ebbfa1ab294@sentry.io/1480772", "environment": "production", "tags": {"puppet_env": "production", "dc_location": "ash2", "service": "gu-bb", "revision": "10b0d91b991b"}}; window.__initial_state__ = {"section": {"repository": {"connectActions": [], "cloneProtocol": "https", "currentRepository": {"scm": "git", "website": "https://github.com/jdkoftinoff/mb-linux-msli", "uuid": "{7fe183eb-5a1e-43c1-af4a-d085585c9537}", "links": {"clone": [{"href": "https://bitbucket.org/__wp__/mb-linux-msli.git", "name": "https"}, {"href": "git@bitbucket.org:__wp__/mb-linux-msli.git", "name": "ssh"}], "self": {"href": "https://bitbucket.org/!api/2.0/repositories/__wp__/mb-linux-msli"}, "html": {"href": "https://bitbucket.org/__wp__/mb-linux-msli"}, "avatar": {"href": "https://bytebucket.org/ravatar/%7B7fe183eb-5a1e-43c1-af4a-d085585c9537%7D?ts=c"}}, "name": "mb-linux-msli", "project": {"description": "Project created by Bitbucket for __WP__", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/__wp__/projects/PROJ"}, "html": {"href": "https://bitbucket.org/__wp__/workspace/projects/PROJ"}, "avatar": {"href": "https://bitbucket.org/account/user/__wp__/projects/PROJ/avatar/32?ts=1447453979"}}, "name": "Untitled project", "created_on": "2015-11-13T22:32:59.539281+00:00", "key": "PROJ", "updated_on": "2015-11-13T22:32:59.539335+00:00", "owner": {"username": "__wp__", "type": "team", "display_name": "__WP__", "uuid": "{55ded115-598c-4864-b0e7-cdef05771294}", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/teams/%7B55ded115-598c-4864-b0e7-cdef05771294%7D"}, "html": {"href": "https://bitbucket.org/%7B55ded115-598c-4864-b0e7-cdef05771294%7D/"}, "avatar": {"href": "https://bitbucket.org/account/__wp__/avatar/"}}}, "workspace": {"name": "__WP__", "type": "workspace", "uuid": "{55ded115-598c-4864-b0e7-cdef05771294}", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/workspaces/__wp__"}, "html": {"href": "https://bitbucket.org/__wp__/"}, "avatar": {"href": "https://bitbucket.org/workspaces/__wp__/avatar/?ts=1543468984"}}, "slug": "__wp__"}, "type": "project", "is_private": false, "uuid": "{e060f8c0-a44d-4706-9d5b-b11f3b7f8ea7}"}, "language": "c", "mainbranch": {"name": "master"}, "full_name": "__wp__/mb-linux-msli", "owner": {"username": "__wp__", "display_name": "__WP__", "uuid": "{55ded115-598c-4864-b0e7-cdef05771294}", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/teams/%7B55ded115-598c-4864-b0e7-cdef05771294%7D"}, "html": {"href": "https://bitbucket.org/%7B55ded115-598c-4864-b0e7-cdef05771294%7D/"}, "avatar": {"href": "https://bitbucket.org/account/__wp__/avatar/"}}, "is_active": true, "created_on": "2012-09-12T18:04:32.423010+00:00", "type": "team", "properties": {}, "has_2fa_enabled": null}, "updated_on": "2012-09-23T15:01:03.144649+00:00", "type": "repository", "slug": "mb-linux-msli", "is_private": false, "description": "Forked from https://github.com/jdkoftinoff/mb-linux-msli."}, "mirrors": [], "menuItems": [{"analytics_label": "repository.source", "is_client_link": true, "icon_class": "icon-source", "target": "_self", "weight": 200, "url": "/__wp__/mb-linux-msli/src", "tab_name": "source", "can_display": true, "label": "Source", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": ["/diff", "/history-node"], "id": "repo-source-link", "type": "menu_item", "children": [], "icon": "icon-source"}, {"analytics_label": "repository.commits", "is_client_link": true, "icon_class": "icon-commits", "target": "_self", "weight": 300, "url": "/__wp__/mb-linux-msli/commits/", "tab_name": "commits", "can_display": true, "label": "Commits", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-commits-link", "type": "menu_item", "children": [], "icon": "icon-commits"}, {"analytics_label": "repository.branches", "is_client_link": true, "icon_class": "icon-branches", "target": "_self", "weight": 400, "url": "/__wp__/mb-linux-msli/branches/", "tab_name": "branches", "can_display": true, "label": "Branches", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-branches-link", "type": "menu_item", "children": [], "icon": "icon-branches"}, {"analytics_label": "repository.pullrequests", "is_client_link": true, "icon_class": "icon-pull-requests", "target": "_self", "weight": 500, "url": "/__wp__/mb-linux-msli/pull-requests/", "tab_name": "pullrequests", "can_display": true, "label": "Pull requests", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-pullrequests-link", "type": "menu_item", "children": [], "icon": "icon-pull-requests"}, {"analytics_label": "repository.jira", "is_client_link": true, "icon_class": "icon-jira", "target": "_self", "weight": 600, "url": "/__wp__/mb-linux-msli/jira", "tab_name": "jira", "can_display": true, "label": "Jira issues", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-jira-link", "type": "menu_item", "children": [], "icon": "icon-jira"}, {"analytics_label": "repository.downloads", "is_client_link": false, "icon_class": "icon-downloads", "target": "_self", "weight": 800, "url": "/__wp__/mb-linux-msli/downloads/", "tab_name": "downloads", "can_display": true, "label": "Downloads", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-downloads-link", "type": "menu_item", "children": [], "icon": "icon-downloads"}], "bitbucketActions": [{"analytics_label": "repository.clone", "is_client_link": false, "icon_class": "icon-clone", "target": "_self", "weight": 100, "url": "#clone", "tab_name": "clone", "can_display": true, "label": "<strong>Clone<\/strong> this repository", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-clone-button", "type": "menu_item", "children": [], "icon": "icon-clone"}, {"analytics_label": "repository.compare", "is_client_link": false, "icon_class": "aui-icon-small aui-iconfont-devtools-compare", "target": "_self", "weight": 400, "url": "/__wp__/mb-linux-msli/branches/compare", "tab_name": "compare", "can_display": true, "label": "<strong>Compare<\/strong> branches or tags", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-compare-link", "type": "menu_item", "children": [], "icon": "aui-icon-small aui-iconfont-devtools-compare"}, {"analytics_label": "repository.fork", "is_client_link": false, "icon_class": "icon-fork", "target": "_self", "weight": 500, "url": "/__wp__/mb-linux-msli/fork", "tab_name": "fork", "can_display": true, "label": "<strong>Fork<\/strong> this repository", "is_premium": null, "is_dropdown_item": false, "anchor": true, "badge_label": null, "analytics_payload": {}, "matching_url_prefixes": [], "id": "repo-fork-link", "type": "menu_item", "children": [], "icon": "icon-fork"}], "activeMenuItem": "source"}}, "global": {"needs_marketing_consent": false, "features": {"fd-send-webhooks-to-webhook-processor": true, "exp-share-to-invite-variation": false, "allocate-with-regions": true, "frontbucket-eager-dispatching-of-exited-code-review": true, "orochi-git-diff-refactor": true, "use-elasticache-lsn-storage": true, "workspaces-api-proxy": true, "webhook_encryption_disabled": true, "uninstall-dvcs-addon-only-when-jira-is-removed": true, "log-asap-errors": true, "connect-iframe-no-sub": true, "support-sending-custom-events-to-the-webhook-processor": true, "sync-aid-revoked-to-workspace": true, "new-analytics-cdn": true, "nav-add-file": false, "custom-default-branch-name-repo-create": true, "allow-users-members-endpoint": true, "remove-deactivated-users-from-followers": true, "whitelisted_throttle_exemption": true, "api-diff-caching": true, "hot-91446-add-tracing-x-b3": true, "reset-changes-requested-status": true, "provision-workspaces-in-hams": true, "provisioning-skip-workspace-creation": true, "record-site-addon-version": true, "restrict-commit-author-data": true, "enable-jwt-repo-filtering": true, "reviewer-status": true, "fd-add-gitignore-dropdown-on-create-repo-page": true, "repo-show-uuid": false, "workspace-member-set-last-accessed": true, "provisioning-install-pipelines-addon": true, "expand-accesscontrol-cache-key": true, "disable-hg": true, "new-code-review": true, "orochi-disable-hooks-with-lockid": true, "fd-prs-client-cache-fallback": true, "fd-ie-deprecation-phase-one": true, "clone-in-xcode": true, "enable-merge-bases-api": true, "bbc.core.disable-repository-statuses-fetch": false, "bms-repository-no-finalize": true, "use-moneybucket": true, "spa-repo-settings--repo-details": true, "use-py-hams-client-asap": true, "sync-workspace-user-active": true, "fetch-all-relevant-jira-projects": true, "connect-iframe-sandbox": true, "nav-next-settings": true, "auth-flow-adg3": true, "consenthub-config-endpoint-update": true, "new-code-review-onboarding-experience": true, "disable-repository-replication-task": true, "lookup-pr-approvers-from-prs": true, "orochi-add-custom-backend": true, "null-mainbranch-implies-none": true, "bbc.core.pride-logo": false, "pr_post_build_merge": true, "fd-ie-deprecation-phase-two": true, "workspace-ui": true, "provisioning-auto-login": true, "bbcdev-13546-caching-defaults": true, "hide-price-annual": true, "fd-jira-compatible-issue-export": true, "account-switcher": true, "user-mentions-repo-filtering": true, "spa-repo-settings--access-keys": true, "read-only-message-migrations": true, "free-daily-repo-limit": true, "svg-based-qr-code": true, "allow-cloud-session": true, "orochi-custom-default-branch-name-repo-create": true, "fd-overview-page-pr-filter-buttons": true, "show-upgrade-plans-banner": true}, "locale": "en", "geoip_country": null, "targetFeatures": {"fd-send-webhooks-to-webhook-processor": true, "orochi-large-merge-message-support": true, "allocate-with-regions": true, "frontbucket-eager-dispatching-of-exited-code-review": true, "orochi-git-diff-refactor": true, "fd-repository-page-loading-error-guard": true, "workspaces-api-proxy": true, "webhook_encryption_disabled": true, "uninstall-dvcs-addon-only-when-jira-is-removed": true, "whitelisted_throttle_exemption": true, "connect-iframe-no-sub": true, "support-sending-custom-events-to-the-webhook-processor": true, "sync-aid-revoked-to-workspace": true, "new-analytics-cdn": true, "log-asap-errors": true, "custom-default-branch-name-repo-create": true, "allow-users-members-endpoint": true, "remove-deactivated-users-from-followers": true, "expand-accesscontrol-cache-key": true, "api-diff-caching": true, "prlinks-installer": true, "rm-empty-ref-dirs-on-push": true, "reset-changes-requested-status": true, "provision-workspaces-in-hams": true, "provisioning-skip-workspace-creation": true, "record-site-addon-version": true, "restrict-commit-author-data": true, "enable-jwt-repo-filtering": true, "show-banner-about-new-review-experience": true, "enable-merge-bases-api": true, "account-switcher": true, "reviewer-status": true, "fd-add-gitignore-dropdown-on-create-repo-page": true, "use-elasticache-lsn-storage": true, "workspace-member-set-last-accessed": true, "provisioning-install-pipelines-addon": true, "consenthub-config-endpoint-update": true, "disable-hg": true, "new-code-review": true, "orochi-disable-hooks-with-lockid": true, "show-pr-update-activity-changes": true, "fd-ie-deprecation-phase-one": true, "clone-in-xcode": true, "fd-undo-last-push": false, "bms-repository-no-finalize": true, "exp-new-user-survey": true, "use-moneybucket": true, "spa-repo-settings--repo-details": true, "use-py-hams-client-asap": true, "atlassian-editor": true, "sync-workspace-user-active": true, "fetch-all-relevant-jira-projects": true, "hot-91446-add-tracing-x-b3": true, "connect-iframe-sandbox": true, "nav-next-settings": true, "auth-flow-adg3": true, "view-source-filtering-upon-timeout": true, "new-code-review-onboarding-experience": true, "disable-repository-replication-task": true, "lookup-pr-approvers-from-prs": true, "orochi-add-custom-backend": true, "null-mainbranch-implies-none": true, "fd-prs-client-cache-fallback": true, "pr_post_build_merge": true, "fd-ie-deprecation-phase-two": true, "workspace-ui": true, "provisioning-auto-login": true, "bbcdev-13546-caching-defaults": true, "hide-price-annual": true, "fd-jira-compatible-issue-export": true, "enable-fx3-client": true, "spa-repo-settings--access-keys": true, "read-only-message-migrations": true, "free-daily-repo-limit": true, "svg-based-qr-code": true, "allow-cloud-session": true, "orochi-custom-default-branch-name-repo-create": true, "markdown-embedded-html": false, "fd-overview-page-pr-filter-buttons": true, "show-upgrade-plans-banner": true}, "isFocusedTask": false, "browser_monitoring": true, "targetUser": {"username": "__wp__", "display_name": "__WP__", "uuid": "{55ded115-598c-4864-b0e7-cdef05771294}", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/teams/%7B55ded115-598c-4864-b0e7-cdef05771294%7D"}, "html": {"href": "https://bitbucket.org/%7B55ded115-598c-4864-b0e7-cdef05771294%7D/"}, "avatar": {"href": "https://bitbucket.org/account/__wp__/avatar/"}}, "is_active": true, "created_on": "2012-09-12T18:04:32.423010+00:00", "type": "team", "properties": {}, "has_2fa_enabled": null}, "is_mobile_user_agent": false, "flags": [], "site_message": "", "isNavigationOpen": true, "path": "/__wp__/mb-linux-msli/src/master/", "focusedTaskBackButtonUrl": null, "whats_new_feed": "https://bitbucket.org/blog/wp-json/wp/v2/posts?categories=196&context=embed&per_page=6&orderby=date&order=desc"}, "repository": {"source": {"section": {"hash": "ae5d81ca8c8265958d9847aecca0505dbce92217", "atRef": null, "ref": {"name": "master", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/repositories/__wp__/mb-linux-msli/refs/branches/master"}, "html": {"href": "https://bitbucket.org/__wp__/mb-linux-msli/branch/master"}}, "target": {"type": "commit", "hash": "ae5d81ca8c8265958d9847aecca0505dbce92217", "links": {"self": {"href": "https://bitbucket.org/!api/2.0/repositories/__wp__/mb-linux-msli/commit/ae5d81ca8c8265958d9847aecca0505dbce92217"}, "html": {"href": "https://bitbucket.org/__wp__/mb-linux-msli/commits/ae5d81ca8c8265958d9847aecca0505dbce92217"}}}}}}}}; window.__settings__ = {"MARKETPLACE_TERMS_OF_USE_URL": null, "JIRA_ISSUE_COLLECTORS": {"code-review-beta": {"url": "https://bitbucketfeedback.atlassian.net/s/d41d8cd98f00b204e9800998ecf8427e-T/-4bqv2z/b/20/a44af77267a987a660377e5c46e0fb64/_/download/batch/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector.js?locale=en-US&collectorId=bb066400", "id": "bb066400"}, "jira-software-repo-page": {"url": "https://jira.atlassian.com/s/1ce410db1c7e1b043ed91ab8e28352e2-T/yl6d1c/804001/619f60e5de428c2ed7545f16096c303d/3.1.0/_/download/batch/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector.js?locale=en-UK&collectorId=064d6699", "id": "064d6699"}, "code-review-rollout": {"url": "https://bitbucketfeedback.atlassian.net/s/d41d8cd98f00b204e9800998ecf8427e-T/-4bqv2z/b/20/a44af77267a987a660377e5c46e0fb64/_/download/batch/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector.js?locale=en-US&collectorId=de003e2d", "id": "de003e2d"}, "source-browser": {"url": "https://bitbucketfeedback.atlassian.net/s/d41d8cd98f00b204e9800998ecf8427e-T/-tqnsjm/b/20/a44af77267a987a660377e5c46e0fb64/_/download/batch/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector/com.atlassian.jira.collector.plugin.jira-issue-collector-plugin:issuecollector.js?locale=en-US&collectorId=c19c2ff6", "id": "c19c2ff6"}}, "STATUSPAGE_URL": "https://bitbucket.status.atlassian.com/", "CANON_URL": "https://bitbucket.org", "CONSENT_HUB_FRONTEND_BASE_URL": "https://preferences.atlassian.com", "API_CANON_URL": "https://api.bitbucket.org", "SOCIAL_AUTH_ATLASSIANID_LOGOUT_URL": "https://id.atlassian.com/logout", "EMOJI_STANDARD_BASE_URL": "https://api-private.atlassian.com/emoji/"}; window.__webpack_nonce__ = 'xxI7cPsOVRt9B81s'; window.isInitialLoadApdex = true; </script> <script nonce="xxI7cPsOVRt9B81s" src="https://d301sr5gafysq2.cloudfront.net/frontbucket/assets/i18n/en.4509eaad.js"></script> <script nonce="xxI7cPsOVRt9B81s" src="https://d301sr5gafysq2.cloudfront.net/frontbucket/assets/present/ajs.53f719bc.js"></script> <script nonce="xxI7cPsOVRt9B81s" src="https://d301sr5gafysq2.cloudfront.net/frontbucket/assets/present/app.8acf32f0.js"></script> <script nonce="xxI7cPsOVRt9B81s" src="https://d301sr5gafysq2.cloudfront.net/frontbucket/assets/present/performance-timing.f1eda5e1.js" defer></script> <script nonce="xxI7cPsOVRt9B81s" type="text/javascript">window.NREUM||(NREUM={});NREUM.info={"beacon":"bam-cell.nr-data.net","queueTime":0,"licenseKey":"a2cef8c3d3","agent":"","transactionName":"NFcGYEdUW0IAVE1QCw0dIkFbVkFYDlkWWw0XUBFXXlBBHwBHSUpKEVcUWwcbQ1gEQEoDNwxHFldQY1xUFhleXBA=","applicationID":"548124220,1841284","errorBeacon":"bam-cell.nr-data.net","applicationTime":263}</script> </body> </html>

Provides a detailed, hierarchical view of ansible-playbook executions with visual insights, task tracing, role dependencies, inventory mapping, variable origins, and more. Designed for easier debugging, auditing, and team collaboration — all from your browser.

FUOcribs is an open source web project aimed at helping university students find roommates and available accomodation. The overall idea behind this program is to help develop coding and real-world problem-solving skills. This project is beginner friendly because no framework would be used and would be built from scratch so we encourage every contributor to give this rpoject their best shot and also __write down good comments in your codes to help another person reading your code learn and understand fast.__ ## Languages required * HTML5 * CSS3 * JAVASCRIPT * PHP * MYSQL ## Tools needed * Web browser * Text editor * You can use any text editor of your choice. Recommended text editors: [Atom](https://atom.io), [Brackets](https://brackets.io), [Vscode](https://code.visualstudio.com/download) * Offline server ([xampp](https://www.apachefriends.org/download.html) or [wamp](http://www.wampserver.com/en/)) ## Workflow This section describes the workflow we are going to follow when working in a new feature or fixing a bug. If you want to contribute, please follow these steps: #### Fork this project Clone the forked project to your local environment, for example: ```git clone https://github.com/DSCfuo/fuocribs.git ``` (Make sure to replace the URL to your own repository). Add the original project as a remote, for this example the name is upstream, feel free to use whatever name you want. git remote add upstream ```https://github.com/DSCfuo/fuocribs.git ``` Forking the project will create a copy of that project in your own GitHub account, you will commit your work against your own repository. #### Updating your local In order to update your local environment to the latest version on master, you will have to pull the changes using the upstream repository, for example: git pull upstream master. This will pull all the new commits from the origin repository to your local environment. #### Features/Bugs When working on a new feature, create a new branch feature/something from the master branch, for example feature/login-form. Commit your work against this new branch and push everything to your forked project. Once everything is completed, you should create a pull request to the original project. Make sure to add a description about your work and a link to the trello task. When fixing a bug, create a new branch fix/something from the master branch, for example fix/css-btn-issues. When completed, push your commits to your forked repository and create a pull request from there. Please make sure to describe what was the problem and how did you fix it. #### Updating your local branch Let's say you've been working on a feature for a couple days, most likely there are new changes in master and your branch is behind. In order to update it to the latest (You might not need/want to do this) you need to pull the latest changes to develop and then rebase your current branch. $ git checkout master $ git pull upstream master $ git checkout feature/something-awesome $ git rebase master After this, your commits will be on top of the master commits. From here you can push to your origin repository and create a pull request. You might have some conflicts while rebasing, try to resolve the conflicts for each individual commit. Rebasing is intimidating at the beginning, if you need help don't be afraid to reach out in slack. #### Pull requests In order to merge a pull request, there should be a couple of approval reviews. Once is approved, we should merge to the master branch using the Squash button in github. When using squash, all the commits will be squashed into one. The idea is to merge features/fixes as oppose of merging each individual commit. This helps when looking back in time for changes in the code base, and if the pull request has a great comment, it's easier to know why that code was introduced.

This XML file does not appear to have any style information associated with it. The document tree is shown below. <xsd:schema xmlns="http://www.springframework.org/schema/mvc" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:beans="http://www.springframework.org/schema/beans" xmlns:tool="http://www.springframework.org/schema/tool" targetNamespace="http://www.springframework.org/schema/mvc" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="https://www.springframework.org/schema/beans/spring-beans-4.3.xsd"/> <xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="https://www.springframework.org/schema/tool/spring-tool-4.3.xsd"/> <xsd:element name="annotation-driven"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"> <![CDATA[ Configures the annotation-driven Spring MVC Controller programming model. Note that this tag works in Web MVC only, not in Portlet MVC! See org.springframework.web.servlet.config.annotation.EnableWebMvc javadoc for details on code-based alternatives to enabling annotation-driven Spring MVC support. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:all minOccurs="0"> <xsd:element name="path-matching" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configures the path matching part of the Spring MVC Controller programming model. Like annotation-driven, code-based alternatives are also documented in EnableWebMvc javadoc. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="suffix-pattern" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to use suffix pattern match (".*") when matching patterns to requests. If enabled a method mapped to "/users" also matches to "/users.*". The default value is true. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="trailing-slash" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to match to URLs irrespective of the presence of a trailing slash. If enabled a method mapped to "/users" also matches to "/users/". The default value is true. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="registered-suffixes-only" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether suffix pattern matching should work only against path extensions explicitly registered when you configure content negotiation. This is generally recommended to reduce ambiguity and to avoid issues such as when a "." appears in the path for other reasons. The default value is false. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="path-helper" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The bean name of the UrlPathHelper to use for resolution of lookup paths. Use this to override the default UrlPathHelper with a custom subclass, or to share common UrlPathHelper settings across multiple HandlerMappings and MethodNameResolvers. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="path-matcher" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The bean name of the PathMatcher implementation to use for matching URL paths against registered URL patterns. Default is AntPathMatcher. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="message-converters" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configures one or more HttpMessageConverter types to use for converting @RequestBody method parameters and @ResponseBody method return values. Using this configuration element is optional. HttpMessageConverter registrations provided here will take precedence over HttpMessageConverter types registered by default. Also see the register-defaults attribute if you want to turn off default registrations entirely. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation> <![CDATA[ An HttpMessageConverter bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation> <![CDATA[ A reference to an HttpMessageConverter bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:sequence> <xsd:attribute name="register-defaults" type="xsd:boolean" default="true"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether or not default HttpMessageConverter registrations should be added in addition to the ones provided within this element. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="argument-resolvers" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configures HandlerMethodArgumentResolver types to support custom controller method argument types. Using this option does not override the built-in support for resolving handler method arguments. To customize the built-in support for argument resolution configure RequestMappingHandlerAdapter directly. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:choice minOccurs="1" maxOccurs="unbounded"> <xsd:element ref="beans:bean" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ The HandlerMethodArgumentResolver (or WebArgumentResolver for backwards compatibility) bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ A reference to a HandlerMethodArgumentResolver bean definition. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.web.method.support.HandlerMethodArgumentResolver"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:complexType> </xsd:element> <xsd:element name="return-value-handlers" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configures HandlerMethodReturnValueHandler types to support custom controller method return value handling. Using this option does not override the built-in support for handling return values. To customize the built-in support for handling return values configure RequestMappingHandlerAdapter directly. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:choice minOccurs="1" maxOccurs="unbounded"> <xsd:element ref="beans:bean" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ The HandlerMethodReturnValueHandler bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ A reference to a HandlerMethodReturnValueHandler bean definition. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.web.method.support.HandlerMethodReturnValueHandler"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:complexType> </xsd:element> <xsd:element name="async-support" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure options for asynchronous request processing. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:all minOccurs="0"> <xsd:element name="callable-interceptors" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ The ordered set of interceptors that intercept the lifecycle of concurrently executed requests, which start after a controller returns a java.util.concurrent.Callable. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element ref="beans:bean" minOccurs="1" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ Registers a CallableProcessingInterceptor. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="deferred-result-interceptors" minOccurs="0"> <xsd:annotation> <xsd:documentation> <![CDATA[ The ordered set of interceptors that intercept the lifecycle of concurrently executed requests, which start after a controller returns a DeferredResult. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element ref="beans:bean" minOccurs="1" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ Registers a DeferredResultProcessingInterceptor. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:all> <xsd:attribute name="task-executor" type="xsd:string"> <xsd:annotation> <xsd:documentation source="java:org.springframework.core.task.AsyncTaskExecutor"> <![CDATA[ The bean name of a default AsyncTaskExecutor to use when a controller method returns a {@link Callable}. Controller methods can override this default on a per-request basis by returning an AsyncTask. By default, a SimpleAsyncTaskExecutor is used which does not re-use threads and is not recommended for production. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.core.task.AsyncTaskExecutor"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> <xsd:attribute name="default-timeout" type="xsd:long"> <xsd:annotation> <xsd:documentation> <![CDATA[ Specify the amount of time, in milliseconds, before asynchronous request handling times out. In Servlet 3, the timeout begins after the main request processing thread has exited and ends when the request is dispatched again for further processing of the concurrently produced result. If this value is not set, the default timeout of the underlying implementation is used, e.g. 10 seconds on Tomcat with Servlet 3. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> </xsd:all> <xsd:attribute name="conversion-service" type="xsd:string"> <xsd:annotation> <xsd:documentation source="java:org.springframework.core.convert.ConversionService"> <![CDATA[ The bean name of the ConversionService that is to be used for type conversion during field binding. This attribute is not required, and only needs to be specified if custom converters need to be configured. If not specified, a default FormattingConversionService is registered with converters to/from common value types. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.core.convert.ConversionService"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> <xsd:attribute name="validator" type="xsd:string"> <xsd:annotation> <xsd:documentation source="java:org.springframework.validation.Validator"> <![CDATA[ The bean name of the Validator that is to be used to validate Controller model objects. This attribute is not required, and only needs to be specified if a custom Validator needs to be configured. If not specified, JSR-303 validation will be installed if a JSR-303 provider is present on the classpath. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.validation.Validator"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> <xsd:attribute name="content-negotiation-manager" type="xsd:string"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.accept.ContentNegotiationManager"> <![CDATA[ The bean name of a ContentNegotiationManager that is to be used to determine requested media types. If not specified, a default ContentNegotiationManager is configured that checks the request path extension first and the "Accept" header second where path extensions such as ".json", ".xml", ".atom", and ".rss" are recognized if Jackson, JAXB2, or the Rome libraries are available. As a fallback option, the path extension is also used to perform a lookup through the ServletContext and the Java Activation Framework (if available). ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.web.accept.ContentNegotiationManager"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> <xsd:attribute name="message-codes-resolver" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The bean name of a MessageCodesResolver to use to build message codes from data binding and validation error codes. This attribute is not required. If not specified the DefaultMessageCodesResolver is used. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.validation.MessageCodesResolver"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> <xsd:attribute name="enable-matrix-variables" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Matrix variables can appear in any path segment, each matrix variable separated with a ";" (semicolon). For example "/cars;color=red;year=2012". By default, they're removed from the URL. If this property is set to true, matrix variables are not removed from the URL, and the request mapping pattern must use URI variable in path segments where matrix variables are expected. For example "/{cars}". Matrix variables can then be injected into a controller method with @MatrixVariable. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="ignore-default-model-on-redirect" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ By default, the content of the "default" model is used both during rendering and redirect scenarios. Alternatively a controller method can declare a RedirectAttributes argument and use it to provide attributes for a redirect. Setting this flag to true ensures the "default" model is never used in a redirect scenario even if a RedirectAttributes argument is not declared. Setting it to false means the "default" model may be used in a redirect if the controller method doesn't declare a RedirectAttributes argument. The default setting is false but new applications should consider setting it to true. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:complexType name="content-version-strategy"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ContentVersionStrategy"> <![CDATA[ A VersionStrategy that calculates an Hex MD5 hashes from the content of the resource and appends it to the file name, e.g. "styles/main-e36d2e05253c6c7085a91522ce43a0b4.css". ]]> </xsd:documentation> </xsd:annotation> <xsd:attribute name="patterns" type="xsd:string" use="required"/> </xsd:complexType> <xsd:complexType name="fixed-version-strategy"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.FixedVersionStrategy"> <![CDATA[ A VersionStrategy that relies on a fixed version applied as a request path prefix, e.g. reduced SHA, version name, release date, etc. ]]> </xsd:documentation> </xsd:annotation> <xsd:attribute name="version" type="xsd:string" use="required"/> <xsd:attribute name="patterns" type="xsd:string" use="required"/> </xsd:complexType> <xsd:complexType name="resource-version-strategy"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.VersionStrategy"> <![CDATA[ A strategy for extracting and embedding a resource version in its URL path. ]]> </xsd:documentation> </xsd:annotation> <xsd:choice minOccurs="1" maxOccurs="1"> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.VersionStrategy"> <![CDATA[ A VersionStrategy bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.VersionStrategy"> <![CDATA[ A reference to a VersionStrategy bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> <xsd:attribute name="patterns" type="xsd:string" use="required"/> </xsd:complexType> <xsd:complexType name="version-resolver"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.VersionResourceResolver"> <![CDATA[ Resolves request paths containing a version string that can be used as part of an HTTP caching strategy in which a resource is cached with a far future date (e.g. 1 year) and cached until the version, and therefore the URL, is changed. ]]> </xsd:documentation> </xsd:annotation> <xsd:choice maxOccurs="unbounded"> <xsd:element type="content-version-strategy" name="content-version-strategy"/> <xsd:element type="fixed-version-strategy" name="fixed-version-strategy"/> <xsd:element type="resource-version-strategy" name="version-strategy"/> </xsd:choice> </xsd:complexType> <xsd:complexType name="resource-resolvers"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ResourceResolver"> <![CDATA[ A list of ResourceResolver beans definition and references. A ResourceResolver provides mechanisms for resolving an incoming request to an actual Resource and for obtaining the public URL path that clients should use when requesting the resource. ]]> </xsd:documentation> </xsd:annotation> <xsd:sequence> <xsd:choice maxOccurs="unbounded"> <xsd:element type="version-resolver" name="version-resolver"/> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ResourceResolver"> <![CDATA[ A ResourceResolver bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ResourceResolver"> <![CDATA[ A reference to a ResourceResolver bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:sequence> </xsd:complexType> <xsd:complexType name="resource-transformers"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ResourceTransformer"> <![CDATA[ A list of ResourceTransformer beans definition and references. A ResourceTransformer provides mechanisms for transforming the content of a resource. ]]> </xsd:documentation> </xsd:annotation> <xsd:sequence> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ResourceTransformer"> <![CDATA[ A ResourceTransformer bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.resource.ResourceTransformer"> <![CDATA[ A reference to a ResourceTransformer bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:sequence> </xsd:complexType> <xsd:complexType name="resource-chain"> <xsd:annotation> <xsd:documentation source="org.springframework.web.servlet.config.annotation.ResourceChainRegistration"> <![CDATA[ Assists with the registration of resource resolvers and transformers. Unless set to "false", the auto-registration adds default Resolvers (a PathResourceResolver) and Transformers (CssLinkResourceTransformer, if a VersionResourceResolver has been manually registered). The resource-cache attribute sets whether to cache the result of resource resolution/transformation; setting this to "true" is recommended for production (and "false" for development). A custom Cache can be configured if a CacheManager is provided as a bean reference in the "cache-manager" attribute, and the cache name provided in the "cache-name" attribute. ]]> </xsd:documentation> </xsd:annotation> <xsd:sequence> <xsd:element name="resolvers" type="resource-resolvers" minOccurs="0" maxOccurs="1"/> <xsd:element name="transformers" type="resource-transformers" minOccurs="0" maxOccurs="1"/> </xsd:sequence> <xsd:attribute name="resource-cache" type="xsd:boolean" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether the resource chain should cache resource resolution. Note that the resource content itself won't be cached, but rather Resource instances. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="auto-registration" type="xsd:boolean" default="true" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to register automatically ResourceResolvers and ResourceTransformers. Setting this property to "false" means that it gives developers full control over the registration process. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-manager" type="xsd:string" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ The name of the Cache Manager to cache resource resolution. By default, a ConcurrentCacheMap will be used. Since Resources aren't serializable and can be dependent on the application host, one should not use a distributed cache but rather an in-memory cache. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-name" type="xsd:string" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ The cache name to use in the configured cache manager. Will use "spring-resource-chain-cache" by default. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> <xsd:complexType name="cache-control"> <xsd:annotation> <xsd:documentation source="org.springframework.web.cache.CacheControl"> <![CDATA[ Generates "Cache-Control" HTTP response headers. ]]> </xsd:documentation> </xsd:annotation> <xsd:attribute name="must-revalidate" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "must-revalidate" directive in the Cache-Control header. This indicates that caches should revalidate the cached response when it's become stale. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="no-cache" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "no-cache" directive in the Cache-Control header. This indicates that caches should always revalidate cached response with the server. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="no-store" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "no-store" directive in the Cache-Control header. This indicates that caches should never cache the response. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="no-transform" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "no-transform" directive in the Cache-Control header. This indicates that caches should never transform (i.e. compress, optimize) the response content. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-public" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "public" directive in the Cache-Control header. This indicates that any cache MAY store the response. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-private" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "private" directive in the Cache-Control header. This indicates that the response is intended for a single user and may not be stored by shared caches. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="proxy-revalidate" type="xsd:boolean" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "proxy-revalidate" directive in the Cache-Control header. This directive has the same meaning as the "must-revalidate" directive, except it only applies to shared caches. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="max-age" type="xsd:int" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "max-age" directive in the Cache-Control header. This indicates that the response should be cached for the given number of seconds. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="s-maxage" type="xsd:int" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "s-maxage" directive in the Cache-Control header. This directive has the same meaning as the "max-age" directive, except it only applies to shared caches. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="stale-while-revalidate" type="xsd:int" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "stale-while-revalidate" directive in the Cache-Control header. This indicates that caches may serve the response after it becomes stale up to the given number of seconds. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="stale-if-error" type="xsd:int" use="optional"> <xsd:annotation> <xsd:documentation> <![CDATA[ Adds a "stale-if-error" directive in the Cache-Control header. When an error is encountered, a cached stale response may be used for the given number of seconds. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> <xsd:element name="resources"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.resource.ResourceHttpRequestHandler"> <![CDATA[ Configures a handler for serving static resources such as images, js, and, css files with cache headers optimized for efficient loading in a web browser. Allows resources to be served out of any path that is reachable via Spring's Resource handling. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element name="cache-control" type="cache-control" minOccurs="0" maxOccurs="1"/> <xsd:element name="resource-chain" type="resource-chain" minOccurs="0" maxOccurs="1"/> </xsd:sequence> <xsd:attribute name="mapping" use="required" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The URL mapping pattern within the current Servlet context to use for serving resources from this handler, such as "/resources/**" ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="location" use="required" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The resource location from which to serve static content, specified at a Spring Resource pattern. Each location must point to a valid directory. Multiple locations may be specified as a comma-separated list, and the locations will be checked for a given resource in the order specified. For example, a value of "/, classpath:/META-INF/public-web-resources/" will allow resources to be served both from the web app root and from any JAR on the classpath that contains a /META-INF/public-web-resources/ directory, with resources in the web app root taking precedence. For URL-based resources (e.g. files, HTTP URLs, etc) this property supports a special prefix to indicate the charset associated with the URL so that relative paths appended to it can be encoded correctly, e.g. "[charset=Windows-31J]https://example.org/path". ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-period" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Specifies the cache period for the resources served by this resource handler, in seconds. The default is to not send any cache headers but rather to rely on last-modified timestamps only. Set this to 0 in order to send cache headers that prevent caching, or to a positive number of seconds in order to send cache headers with the given max-age value. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="order" type="xsd:token"> <xsd:annotation> <xsd:documentation> <![CDATA[ Specifies the order of the HandlerMapping for the resource handler. The default order is Ordered.LOWEST_PRECEDENCE - 1. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="default-servlet-handler"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler"> <![CDATA[ Configures a handler for serving static resources by forwarding to the Servlet container's default Servlet. Use of this handler allows using a "/" mapping with the DispatcherServlet while still utilizing the Servlet container to serve static resources. This handler will forward all requests to the default Servlet. Therefore it is important that it remains last in the order of all other URL HandlerMappings. That will be the case if you use the "annotation-driven" element or alternatively if you are setting up your customized HandlerMapping instance be sure to set its "order" property to a value lower than that of the DefaultServletHttpRequestHandler, which is Integer.MAX_VALUE. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="default-servlet-name" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The name of the default Servlet to forward to for static resource requests. The handler will try to autodetect the container's default Servlet at startup time using a list of known names. If the default Servlet cannot be detected because of using an unknown container or because it has been manually configured, the servlet name must be set explicitly. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="interceptors"> <xsd:annotation> <xsd:documentation> <![CDATA[ The ordered set of interceptors that intercept HTTP Servlet Requests handled by Controllers. Interceptors allow requests to be pre/post processed before/after handling. Each interceptor must implement the org.springframework.web.servlet.HandlerInterceptor or org.springframework.web.context.request.WebRequestInterceptor interface. The interceptors in this set are automatically detected by every registered HandlerMapping. The URI paths each interceptor applies to are configurable. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:choice maxOccurs="unbounded"> <xsd:choice> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Registers an interceptor that intercepts every request regardless of its URI path.. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation> <![CDATA[ Registers an interceptor that intercepts every request regardless of its URI path.. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> <xsd:element name="interceptor"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.handler.MappedInterceptor"> <![CDATA[ Registers an interceptor that interceptors requests sent to one or more URI paths. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element name="mapping" maxOccurs="unbounded"> <xsd:complexType> <xsd:attribute name="path" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ A path into the application intercepted by this interceptor. Exact path mapping URIs (such as "/myPath") are supported as well as Ant-stype path patterns (such as /myPath/**). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="exclude-mapping" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:attribute name="path" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ A path into the application that should not be intercepted by this interceptor. Exact path mapping URIs (such as "/admin") are supported as well as Ant-stype path patterns (such as /admin/**). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:choice> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation> <![CDATA[ The interceptor's bean definition. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation> <![CDATA[ A reference to an interceptor bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:choice> <xsd:attribute name="path-matcher" type="xsd:string"> <xsd:annotation> <xsd:documentation source="java:org.springframework.util.PathMatcher"> <![CDATA[ The bean name of a PathMatcher implementation to use with nested interceptors. This is an optional, advanced property required only if using custom PathMatcher implementations that support mapping metadata other than the Ant path patterns supported by default. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:org.springframework.util.PathMatcher"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="view-controller"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.mvc.ParameterizableViewController"> <![CDATA[ Map a simple (logic-less) view controller to a specific URL path (or pattern) in order to render a response with a pre-configured status code and view. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="path" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The URL path (or pattern) the controller is mapped to. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="view-name" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the view name to return. Optional. If not specified, the view controller will return null as the view name in which case the configured RequestToViewNameTranslator will select the view name. The DefaultRequestToViewNameTranslator for example translates "/foo/bar" to "foo/bar". ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="status-code" type="xsd:int"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the status code to set on the response. Optional. If not set the response status will be 200 (OK). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="redirect-view-controller"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.mvc.ParameterizableViewController"> <![CDATA[ Map a simple (logic-less) view controller to the given URL path (or pattern) in order to redirect to another URL. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="path" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The URL path (or pattern) the controller is mapped to. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="redirect-url" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ By default, the redirect URL is expected to be relative to the current ServletContext, i.e. as relative to the web application root. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="status-code" type="xsd:int"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the specific redirect 3xx status code to use. If not set, org.springframework.web.servlet.view.RedirectView will select MOVED_TEMPORARILY (302) by default. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="context-relative" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to interpret a given redirect URL that starts with a slash ("/") as relative to the current ServletContext, i.e. as relative to the web application root. The default is "true". ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="keep-query-params" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to propagate the query parameters of the current request through to the target redirect URL. The default is "false". ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="status-controller"> <xsd:annotation> <xsd:documentation source="java:org.springframework.web.servlet.mvc.ParameterizableViewController"> <![CDATA[ Map a simple (logic-less) controller to the given URL path (or pattern) in order to sets the response status to the given code without rendering a body. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="path" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The URL path (or pattern) the controller is mapped to. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="status-code" type="xsd:int" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The status code to set on the response. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:complexType name="contentNegotiationType"> <xsd:all> <xsd:element name="default-views" minOccurs="0"> <xsd:complexType> <xsd:sequence> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation> <![CDATA[ A bean definition for an org.springframework.web.servlet.View class. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation> <![CDATA[ A reference to a bean for an org.springframework.web.servlet.View class. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:all> <xsd:attribute name="use-not-acceptable" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Indicate whether a 406 Not Acceptable status code should be returned if no suitable view can be found. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> <xsd:complexType name="urlViewResolverType"> <xsd:attribute name="prefix" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The prefix that gets prepended to view names when building a URL. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="suffix" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The suffix that gets appended to view names when building a URL. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-views" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Enable or disable thew caching of resolved views. Default is "true": caching is enabled. Disable this only for debugging and development. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="view-class" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The view class that should be used to create views. Configure this if you want to provide a custom View implementation, typically a ub-class of the expected View type. ]]> </xsd:documentation> <xsd:appinfo> <tool:annotation kind="ref"> <tool:expected-type type="java:java.lang.Class"/> </tool:annotation> </xsd:appinfo> </xsd:annotation> </xsd:attribute> <xsd:attribute name="view-names" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the view names (or name patterns) that can be handled by this view resolver. View names can contain simple wildcards such that 'my*', '*Report' and '*Repo*' will all match the view name 'myReport'. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> <xsd:element name="view-resolvers"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure a chain of ViewResolver instances to resolve view names returned from controllers into actual view instances to use for rendering. All registered resolvers are wrapped in a single (composite) ViewResolver with its order property set to 0 so that other external resolvers may be ordere ]]> <![CDATA[ d before or after it. When content negotiation is enabled the order property is set to highest priority instead with the ContentNegotiatingViewResolver encapsulating all other registered view resolver instances. That way the resolvers registered through the MVC namespace form self-encapsulated resolver chain. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:choice minOccurs="1" maxOccurs="unbounded"> <xsd:element name="content-negotiation" type="contentNegotiationType"> <xsd:annotation> <xsd:documentation> <![CDATA[ Registers a ContentNegotiatingViewResolver with the list of all other registered ViewResolver instances used to set its "viewResolvers" property. See the javadoc of ContentNegotiatingViewResolver for more details. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element name="jsp" type="urlViewResolverType"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register an InternalResourceViewResolver bean for JSP rendering. By default, "/WEB-INF/" is registered as a view name prefix and ".jsp" as a suffix. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element name="tiles" type="urlViewResolverType"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a TilesViewResolver based on Tiles 3.x. To configure Tiles you must also add a top-level <mvc:tiles-configurer> element or declare a TilesConfigurer bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element name="freemarker" type="urlViewResolverType"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a FreeMarkerViewResolver. By default, ".ftl" is configured as a view name suffix. To configure FreeMarker you must also add a top-level <mvc:freemarker-configurer> element or declare a FreeMarkerConfigurer bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element name="groovy" type="urlViewResolverType"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a GroovyMarkupViewResolver. By default, ".tpl" is configured as a view name suffix. To configure the Groovy markup template engine you must also add a top-level <mvc:groovy-configurer> element or declare a GroovyMarkupConfigurer bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element name="script-template" type="urlViewResolverType"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a ScriptTemplateViewResolver. To configure the Script engine you must also add a top-level <mvc:script-template-configurer> element or declare a ScriptTemplateConfigurer bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element name="bean-name" maxOccurs="1"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a BeanNameViewResolver bean. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:bean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a ViewResolver as a direct bean declaration. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> <xsd:element ref="beans:ref"> <xsd:annotation> <xsd:documentation> <![CDATA[ Register a ViewResolver through references to an existing bean declaration. ]]> </xsd:documentation> </xsd:annotation> </xsd:element> </xsd:choice> <xsd:attribute name="order" type="xsd:int"> <xsd:annotation> <xsd:documentation> <![CDATA[ ViewResolver's registered through this element are encapsulated in an instance of org.springframework.web.servlet.view.ViewResolverComposite and follow the order of registration. This attribute determines the order of the ViewResolverComposite itself relative to any additional ViewResolver's (not registered through this element) present in the Spring configuration By default this property is not set, which means the resolver is ordered at Ordered.LOWEST_PRECEDENCE unless content negotiation is enabled in which case the order (if not set explicitly) is changed to Ordered.HIGHEST_PRECEDENCE. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="tiles-configurer"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure Tiles 3.x by registering a TilesConfigurer bean. This is a shortcut alternative to declaring a TilesConfigurer bean directly. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element name="definitions" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:attribute name="location" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The location of a file containing Tiles definitions (or a Spring resource pattern). If no Tiles definitions are registerd, then "/WEB-INF/tiles.xml" is expected to exists. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> </xsd:sequence> <xsd:attribute name="check-refresh" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to check Tiles definition files for a refresh at runtime. Default is "false". ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="validate-definitions" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether to validate the Tiles XML definitions. Default is "true". ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="definitions-factory" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The Tiles DefinitionsFactory class to use. Default is Tiles' default. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="preparer-factory" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The Tiles PreparerFactory class to use. Default is Tiles' default. Consider "org.springframework.web.servlet.view.tiles3.SimpleSpringPreparerFactory" or "org.springframework.web.servlet.view.tiles3.SpringBeanPreparerFactory" (see javadoc). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="freemarker-configurer"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure FreeMarker for view resolution by registering a FreeMarkerConfigurer bean. This is a shortcut alternative to declaring a FreeMarkerConfigurer bean directly. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element name="template-loader-path" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:attribute name="location" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The location of a FreeMarker template loader path (or a Spring resource pattern). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> <xsd:element name="groovy-configurer"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure the Groovy markup template engine for view resolution by registering a GroovyMarkupConfigurer bean. This is a shortcut alternative to declaring a GroovyMarkupConfigurer bean directly. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="auto-indent" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether you want the template engine to render indents automatically. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="cache-templates" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ If enabled templates are compiled once for each source (URL or File). It is recommended to keep this flag to true unless you are in development mode and want automatic reloading of templates. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="resource-loader-path" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The Groovy markup template engine resource loader path via a Spring resource location. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="script-template-configurer"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure the script engine for view resolution by registering a ScriptTemplateConfigurer bean. This is a shortcut alternative to declaring a ScriptTemplateConfigurer bean directly. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element name="script" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:attribute name="location" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The location of the script to be loaded by the script engine (library or user provided). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> </xsd:sequence> <xsd:attribute name="engine-name" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ The script engine name to use by the view. The script engine must implement Invocable. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="render-object" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The object where belong the render function. For example, in order to call Mustache.render(), renderObject should be set to Mustache and renderFunction to render. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="render-function" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the render function name. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="content-type" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the content type to use for the response (text/html by default). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="charset" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Set the charset used to read script and template files (UTF-8 by default). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="resource-loader-path" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ The script engine resource loader path via a Spring resource location. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="shared-engine" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ When set to false, use thread-local ScriptEngine instances instead of one single shared instance. This flag should be set to false for those using non thread-safe script engines with templating libraries not designed for concurrency, like Handlebars or React running on Nashorn for example. In this case, Java 8u60 or greater is required due to this bug: https://bugs.openjdk.java.net/browse/JDK-8076099. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> <xsd:element name="cors"> <xsd:annotation> <xsd:documentation> <![CDATA[ Configure cross origin requests processing. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:sequence> <xsd:element name="mapping" minOccurs="1" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation> <![CDATA[ Enable cross origin requests processing on the specified path pattern. By default, all origins, GET HEAD POST methods, all headers and credentials are allowed and max age is set to 30 minutes. ]]> </xsd:documentation> </xsd:annotation> <xsd:complexType> <xsd:attribute name="path" type="xsd:string" use="required"> <xsd:annotation> <xsd:documentation> <![CDATA[ A path into the application that should handle CORS requests. Exact path mapping URIs (such as "/admin") are supported as well as Ant-stype path patterns (such as /admin/**). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="allowed-origins" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Comma-separated list of origins to allow, e.g. "https://domain1.com, https://domain2.com". The special value "*" allows all domains (default). Note that CORS checks use values from "Forwarded" (RFC 7239), "X-Forwarded-Host", "X-Forwarded-Port", and "X-Forwarded-Proto" headers, if present, in order to reflect the client-originated address. Consider using the ForwardedHeaderFilter in order to choose from a central place whether to extract and use such headers, or whether to discard them. See the Spring Framework reference for more on this filter. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="allowed-methods" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Comma-separated list of HTTP methods to allow, e.g. "GET, POST". The special value "*" allows all method. By default GET, HEAD and POST methods are allowed. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="allowed-headers" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Comma-separated list of headers that a pre-flight request can list as allowed for use during an actual request. The special value of "*" allows actual requests to send any header (default). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="exposed-headers" type="xsd:string"> <xsd:annotation> <xsd:documentation> <![CDATA[ Comma-separated list of response headers other than simple headers (i.e. Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma) that an actual response might have and can be exposed. Empty by default. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="allow-credentials" type="xsd:boolean"> <xsd:annotation> <xsd:documentation> <![CDATA[ Whether user credentials are supported (true by default). ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> <xsd:attribute name="max-age" type="xsd:long"> <xsd:annotation> <xsd:documentation> <![CDATA[ How long, in seconds, the response from a pre-flight request can be cached by clients. 1800 seconds (30 minutes) by default. ]]> </xsd:documentation> </xsd:annotation> </xsd:attribute> </xsd:complexType> </xsd:element> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>

The process that was developed provides a way to access a public repository of biomedical papers (PubMed) using its API for Python (PyMed) and extract information on a topic (Covid-19) that is processed using Natural Language Processing (NLP) techniques to extract semantic triplets in the format of “subject, predicate, object”. The software that is used for the semantic triplet extractions is SemRep, a UMLS-based program that extracts three-part propositions, called semantic predications from sentences in biomedical text. Additional processing is performed by implementing various techniques of data mining to generate and maintain additional information for the origin and the quality of those semantic triplets. This information is then stored in a graph database (Neo4J), which can be explored using a query language (Cypher) and presented in a way that is easy to understand and use for anyone. This process can be used to aid researchers in their expedition of research into Covid-19. The most important findings of the reasearch were the corellation among critical aspects of covid-19, along with its relevant/accurate source for further investigation. Considering that the study and analysis of how language is used figuratively and literally is proven to be a challenging task, the outcome of this project can serve clinicians needs and it can be easily adjusted to provide insightful data for any other medical topic. Keywords: covid-19, graph databases, data mining ,semantic predications, pubmed, semrep, neo4j,cypher

Use tensorflow to implement a Deep Neural Network for real time lane detection mainly based on the IEEE IV conference paper "Towards End-to-End Lane Detection: an Instance Segmentation Approach".You can refer to their paper for details https://arxiv.org/abs/1802.05591. This model consists of a encoder-decoder stage, binary semantic segmentation stage and instance semantic segmentation using discriminative loss function for real time lane detection task. The main network architecture is as follows: Train your own model : Data Preparation Firstly you need to organize your training data refer to the data/training_data_example folder structure. And you need to generate a train.txt and a val.txt to record the data used for training the model. The training samples are consist of three components. A binary segmentation label file and a instance segmentation label file and the original image. The binary segmentation use 255 to represent the lane field and 0 for the rest. The instance use different pixel value to represent different lane field and 0 for the rest. All your training image will be scaled into the same scale according to the config file. Use the script here to generate the tensorflow records file python tools/make_tusimple_tfrecords.py Train model In my experiment the training epochs are 80010, batch size is 4, initialized learning rate is 0.001 and use polynomial decay with power 0.9. About training parameters you can check the global_configuration/config.py for details. You can switch --net argument to change the base encoder stage. If you choose --net vgg then the vgg16 will be used as the base encoder stage and a pretrained parameters will be loaded. And you can modified the training script to load your own pretrained parameters or you can implement your own base encoder stage. You may call the following script to train your own model python tools/train_lanenet_tusimple.py You may monitor the training process using tensorboard tools During my experiment the Total loss drops as follows: Recently updates 2018.11.10 : Adjust some basic cnn op according to the new tensorflow api. Use the traditional SGD optimizer to optimize the whole model instead of the origin Adam optimizer used in the origin paper. I have found that the SGD optimizer will lead to more stable training process and will not easily stuck into nan loss which may often happen when using the origin code.

Autism means that a person develops in a different way and has problems with communication and interaction with other people, as well as unusual behaviors such as repetitive motions or enthusiasm for very narrowly specialized interests. However, this is only a clinical definition, and this is not the most important of what you need to know about autism. So ... what does an ordinary person need to know about autism? There are a lot of misconceptions, important facts that people do not even know about, and several universal truths that are always ignored when it comes to disability. So, let's list them. 1.Autism is diverse. Very, very diverse. Ever heard the saying: "If you know one autistic person, do you know ... only one autistic person"? It's true. We like completely different things, we behave differently, we have different talents, different interests and different skills. Gather a group of autistic people and look at them. You will find that these people are as much different from each other as neurotypical people. Perhaps, autism differ from each other even more. Every autistic person is individual, and you can not make any assumptions about him only on the basis of his diagnosis, except as "Probably this person has problems with communication and social interaction." And, you see, this is a very general statement. 2. Autism does not define a person's personality ... but it is still a fundamental part of our being. Someone kindly reminded me of the missed second item on this list, so I just added it! I always miss something ... especially if it's about something like "If it's written that it's about a list of ten items, then there should be ten points." The thing is that it's difficult for me to perceive the whole picture, and instead I constantly focus on details like "Did I make a spelling mistake?" If I no longer had a pervasive developmental disorder, I would have been diagnosed with impaired attention like ADHD - in my head I have not only autism. In fact, autism is just one of many phenomena, and most of them are not diagnoses. I am an autistic, but I have huge problems with organizing my actions and switching to a new task, which usually happens in people with ADHD. I am well read, but there are serious problems with arithmetic, but not with the score. I'm altruist, introvert, I have my own opinion on any occasion, and I adhere to moderate views in politics. I'm a Christian, a student, a scientist ... How much everything comes in identity! However, autism is a little coloring, as if you are looking at something through the colored glass. So if you think that I would be the same person without my autism, then you are unequivocally mistaken! Because how can you remain the same person, if your mind starts to think differently, learn differently, and you will have a completely different view of the world? Autism is not just an additive. This is the very basis for the development of the personality of an autistic person. I have only one brain, and "autism" is just a label that describes the features of the work of this brain. 3.Having autism does not make your life meaningless. Disability generally does not mean that your life is meaningless, and in this respect, autism is not different from any other disability. Constraints in communication and social interaction, coupled with learning difficulties and sensory problems that are inherent in us, do not mean that the life of an autistic person is worse than the life of a neurotypical person. Sometimes people assume that if you have a disability, then your life is by definition worse, but I think they are just too inclined to look at everything from their own point of view. People who have been neurotic in their entire lives begin to think about what they would feel if they suddenly lost their skills ... while in reality one must imagine that they never had these skills, or that they have developed other skills and a different view of the world. Disability itself is a neutral fact, not a tragedy. With respect to autism, tragedy is not autism itself, but related prejudices. It does not matter what restrictions a person has, autism does not prevent him from being part of his family, part of his community and a person whose life has an intrinsic value. 4.Autistic people are capable of love to the same extent as any other people. Love for other people does not depend on the ability to speak fluently, understand the expression of strangers or remember that when you try to make friends with someone, it's better not to talk about wild cats for an hour and a half without stopping. Perhaps we do not know how to copy the emotions of other people, but we are capable of the same compassion as all the others. We just express it differently. Neurotics are usually trying to express sympathy, autistics (at least those that look like me, as I said - we are very different) are trying to fix a problem that initially upset the person. I see no reason to think that one approach is better than another ... Oh, and one thing: although I am an asexual, among the people of the spectrum of autism I am in the minority. Autistic adults, with any form of autism, can fall in love, marry and have a family. A few of my autistic friends are married or go out on dates. 5.The presence of autism does not prevent a person from learning. Actually does not interfere. We grow, and we learn throughout life, just like any other person. Sometimes I hear people say that their autistic children "recovered". However, in fact, they only describe how their children grow, develop and learn in the right environment. They actually devalue the efforts and achievements of their children, writing off them for the last drug or other treatment. I have come a long way from a two-year-old girl, who was crying all day and night, constantly running around in circles and making violent hysterics from the touch of wool. Now I'm in college and I almost achieved independence. (I, true, still can not bear woolen cloth). In a good environment, with good teachers, training will be almost inevitable. This is the focus of research on autism: how best to teach us what we need to know about this world that is not fit for us. 6.The origin of autism is almost entirely genetic. The hereditary component of autism is about 90%, which means that almost every case of autism can be reduced to a certain combination of genes, be it the "botanist genes" that were transmitted from your parents, or they are new mutations that have arisen only in your generation. Autism has nothing to do with the vaccinations you have been given, and it has nothing to do with what you eat. Ironically, despite the arguments of the opponents of vaccines, the only proven non-genetic cause of autism is the congenital rubella syndrome that occurs when a pregnant woman (usually not vaccinated) gets rubella. People, do all the necessary vaccinations. They save lives - millions of people who die every year from diseases that could be prevented by vaccines would agree. 7.Autistic people are not sociopaths. I know, probably, you do not think so, but still it should be repeated again. "Autism" is often associated with the image of a person who absolutely does not care about the existence of other people, while in reality, it's just a communication problem. We do not care about other people. Moreover, I know several autists who are so panicky about accidentally saying "something is wrong" and touching other people's feelings that as a result they are constantly shy and nervous. Even nonverbal autistic children show the same attachment to their parents, which is not autistic. In reality, autistic adults commit crimes much less often than neurotype’s. (However, I do not think that this is due to our innate goodness.) In the end, it is very often a crime - it is social activity). 8.There is no "epidemic of autism". In other words: the number of people diagnosed with autism is increasing, but the total number of autistic people remains the same. Studies conducted among adults show that the level of autism among them is the same as among children. With what are all these new cases related? Simply with the fact that now diagnoses are also made in milder forms of autism, including due to the recognition that Asperger syndrome is autism without speech delay (previously the diagnosis was not raised if you could speak). In addition, they began to include people with mental retardation (as it turned out, in addition to mental retardation, they very often have autism). As a result, the number of diagnoses "mental retardation" decreased, and the number of diagnoses "autism", respectively, increased. Nevertheless, rhetoric about the "autism epidemic" had a positive effect: thanks to it we learned about the real prevalence of autism, and we know that it is not necessarily heavy, and we know exactly how it manifests, which allows children to receive the necessary support from an early age. 9.Autistic people can be happy without healing. And we are not talking about some second-rate happiness on the principle of "better something than nothing." Most neurotics (if they are not artists or children) will never notice the beauty in arrangement of cracks in the asphalt pavement, or how beautifully the colors are played on the spilled gasoline after the rain. They probably will never know what it's like to give up entirely to a particular topic and study everything about it as much as possible. They will never know the beauty of the facts that were brought into a certain system. They probably will never know what it's like to wave your hands with happiness, or what it's like to forget about everything because of the sensation of the cat's fur. In the life of autistics, there are wonderful aspects, as, most likely, they are in the life of neurotype’s. No, understand me correctly: this is a difficult life. The world is not adapted to the existence of autistic people, and autistic people and their families face strangely every day prejudices. However, happiness in autism is not reduced to "courage" or "overcoming". It's just happiness. You do not have to be normal to be happy. 1o. Autistic people want to be a part of this world. We really want this ... just on our own terms. We want to be accepted. We want to go to school. We want to work. We want to be listened to and heard. We have hopes and dreams of our future and the future of this world. We want to contribute. Many of us want to have a family. We differ from the norm, but it is diversity that makes this world stronger, not weaker. The more images of thinking, the more ways will be found to solve a particular problem. The diversity of society means that if a problem arises, we will have different minds at hand, and one of them will find a solution.

Tools for OpenShift Origin administration tasks

in the AWS platform practicing, we needs to handle the CDN log ETL task from CDN origin Storage of Edgecast, serverless maintenance all by lambda, and also configuration management all by OPSWORKS/SYSTEMS MANAGER. and infrastructure as code methodology by Cloudformation, other useful tools such as Athena, RDS, ELastic Beanstalk, codepipeline, there collects all my effort and practising in AWS Area

Significant sentences are made of expressive words. The information about words, their meanings, and origin are provided through widely available dictionaries. But dictionary entries developed for the convenience of human readers, not for machines. Different knowledge base datasets i.e. FB15K, Deep-dive are used to provide a more effective combination of traditional information and modern computing. To use such datasets different NLP (Natural Language Processing) approaches in the area of Word and Graph embeddings were used to extract data into a meaningful form for different techniques such as recommendation. In this research paper, we differentiate Word2vec and Node2vec both NLP approaches on the MovieLens dataset for the recommendation. An epic technique to compute movie similarities for the recommendation that influences having item features. These methods are widely used in web search and content-based recommendation. We compare the Word2vec and Node2vec methods which influence user previous interactions with items and their features to compute low-dimensional embeddings of movies. Categorically, the movie features are injected into the model as side information to standardize the movie embeddings. We show that the new movie representations lead to better performance on recommendation tasks on an open MovieLens dataset. Word2vec is used for word embedding while for graph embeddings we used the Node2vec method. In this research paper, we examine both neural models based on their training and sampling strategy for the recommendation.

This data was extracted from the census bureau database found at http://www.census.gov/ftp/pub/DES/www/welcome.html Donor: Ronny Kohavi and Barry Becker, Data Mining and Visualization Silicon Graphics. e-mail: ronnyk@sgi.com for questions. Split into train-test using MLC++ GenCVFiles (2/3, 1/3 random). 48842 instances, mix of continuous and discrete (train=32561, test=16281) 45222 if instances with unknown values are removed (train=30162, test=15060) Duplicate or conflicting instances : 6 Class probabilities for adult.all file Probability for the label '>50K' : 23.93% / 24.78% (without unknowns) Probability for the label '<=50K' : 76.07% / 75.22% (without unknowns) Extraction was done by Barry Becker from the 1994 Census database. A set of reasonably clean records was extracted using the following conditions: ((AAGE>16) && (AGI>100) && (AFNLWGT>1)&& (HRSWK>0)) Prediction task is to determine whether a person makes over 50K a year. Conversion of original data as follows: 1. Discretized a gross income into two ranges with threshold 50,000. 2. Convert U.S. to US to avoid periods. 3. Convert Unknown to "?" 4. Run MLC++ GenCVFiles to generate data,test. Description of fnlwgt (final weight) The weights on the CPS files are controlled to independent estimates of the civilian noninstitutional population of the US. These are prepared monthly for us by Population Division here at the Census Bureau. We use 3 sets of controls. These are: 1. A single cell estimate of the population 16+ for each state. 2. Controls for Hispanic Origin by age and sex. 3. Controls by Race, age and sex. We use all three sets of controls in our weighting program and "rake" through them 6 times so that by the end we come back to all the controls we used. The term estimate refers to population totals derived from CPS by creating "weighted tallies" of any specified socio-economic characteristics of the population. People with similar demographic characteristics should have similar weights. There is one important caveat to remember about this statement. That is that since the CPS sample is actually a collection of 51 state samples, each with its own probability of selection, the statement only applies within state. Dataset Link https://archive.ics.uci.edu/ml/machine-learning-databases/adult/ Problem 1: Prediction task is to determine whether a person makes over 50K a year. Problem 2: Which factors are important Problem 3: Which algorithms are best for this dataset.

An HTTP Server task for grunt, similar to Python's SimpleHTTPServer, with Cross-Origin Resource Sharing and No-Cache options.

RTO Classification Problem: RTO (Return to Origin) Problem class: Supervised Classification Problem description: RTO (Return to Origin) is a Classification Problem in eCommerce platforms where Many customers cancel their when the product is already on shipping. Then customer don't response and the product is return back to office. Problem Task: Have to predict who will Cancel the product order.

The goal of the task is to use Image Processing and OpenCV techniques to identify shortest route between an origin and a destination as well as detect presence of obstacles if any, on the path supposed to be traversed by the robot.

It has become very common nowadays, especially after the outbreak of the COVID-19 pandemic, to send or receive items online (food, goods, clothes, documents, . . . ). Hence, it is more and more important for companies to efficiently schedule the dispatching of items through different couriers, in order to minimize the transportation costs. As the combinatorial decision and optimization expert, the student is assigned to solve the Multiple Couriers Planning (MCP) problem which is defined as follows. We have m couriers that must distribute n ≥ m items at different customer locations. Each courier i has a maximum load size li. Each item j has a distribution point dj and a size sj (which can represent for instance a weight or a volume). The goal of MCP is to decide for each courier the items to be distributed and plan a tour (i.e. a sequence of location points to visit) to perform the necessary distribution tasks. Each courier tour must start and end at a given origin point o. Moreover, the maximum load li of the courier i should be respected when items are assigned to it. The objective is to minimize the total tour distance.

Technology transfer in the pharmaceutical industry: Effective turn of events and commercialization of creative advances is consistently laden with challenges, complex undertaking, and an assortment of improvement devices exist to advance this movement, by a long shot the most famous way to deal with straightforwardly advancing fruitful development is through innovation move. Effective innovation move requires cautiously concentrating on various circumstances like a cautious assessment of extreme assembling necessities from the get-go in innovative work and the subsequent advancement of hearty cycles that withstand huge scope activity, understanding and transfer of technology in the pharmaceutical industry The principle objective of this review is to give a reasonable system to innovation move process in the drug industry. Innovation move is a cycle to move data and advances important to make quality medication item reliably or innovation move is the most common way of taking a creation from its origin in a research facility to a marketed item In the drug business, “innovation move” alludes to the cycles that are required for effective advancement from drug revelation to item improvement to clinical preliminaries to full-scale commercialization Factors that Affect the Process of Technology Transfer in the Pharmaceutical Industry : • Investment in R&D. • Establishing the connection between creation and exploration. • Data advancement inside the area of innovation move strategies. • Organizational, equipment and enlightening frameworks. • Awareness of essential and fundamental variable requirements for innovation move. • Consideration of existing and old advances Rules/Significance OF technology transfer https://en.wikipedia.org/wiki/Pharmaceutical_industrypharmaceuticle industry To explain essential data to move innovation from Research and development to real assembling by figuring out different data got during Research and development. Exhibition of essential data to innovation move from innovative work to real assembling. To explain essential data to move innovation of existing items between different assembling places. To embody explicit techniques and marks of worry for smooth innovation move. For the smooth assembling of marketed items. This is relevant to the innovation move through Research and development and creation of medication (artificially orchestrated medication substances and medication items) and the innovation move identified with post-advertising changes in assembling places. a definitive objective for fruitful innovation move is to have reported proof that the assembling system for drug substance and medication items are strong and powerful in creating the medication and medication items agreeing with the enlisted details and Great Assembling Practice prerequisite. General effect of the innovation transfer program. I. Improvement of the examination relevance and its advancement in far-off nations. ii. Commitment to the creation and solidification of exploration gatherings and places for innovation improvement, including the preparation of youthful examination understudies. iii. Elevate interdisciplinary tasks to be created in the district of interest. Why/Reasons for innovation transfer? Many reasons exist why an organization might want to move its innovation to different gatherings: 1)Due to the absence of assembling limit, the engineer of the innovation may just have to produce equipment that is reasonable for lab and limited scope tasks and should cooperate with one more association to do huge scope fabricating 2) Because of the absence of assets to dispatch items financially. The first creator of innovation may just have assets to direct beginning phase examination and Stage I and II clinical preliminaries. 3) Because of the absence of promoting dispersion and conveyance capacity. The designer of the innovation might have completely fostered the innovation and even have gotten administrative endorsements and item enlistments, however, it might not have the promoting and circulation channels and should team up with another association that has the capacity. 4)Forming coalitions with accomplices that can advance the improvement of the innovation to take it to showcase. 5)Forming coalitions with accomplices with assembling capacity. 6)Forming coalitions with accomplices with showcasing and conveyance capacity. 7)Exploitation in an alternate field of utilization. CONCLUSION From a drug contract producer’s (CMO) viewpoint, the attention is on the best way to convey better outcomes to customers according to a task from the executive’s perspective. There are key contemplations to prompt a fruitful drug tech move and at last, an item dispatch to advertise including a committed venture the board program, normalized tech moves methodology and vigorous quality frameworks.

ascended task management for small teams

the original login/signup API and backhand

No description available

A collection of Windows Task Manager Binaries since Windows NT4

Use ECS task role credentials when running Unifiedstreaming Origin

tasks saved from backup - origin repository is deleted now

In this task, we evaluated how accurately the bilingual universal concepts (BUC) model can map one word in the origin language to the translation of the word in the target language.

This repository explores the application of deep learning techniques to the task of geolocating tweets. It includes implementations of various models designed to accurately pinpoint the origin of tweets to specific provinces or states.

Motivation with the rapid advancement of AI , distinguishing between human-written and AI generated content is challenging. The task aim to accurately identify the origin of textual content , contributing to the development of robust techniques for detecting AI-generated content.

The provided code represents a simple Actix web application in Rust for managing tasks and users. The application uses Actix framework for handling HTTP requests, Actix-Web for creating routes, Actix-CORS for enabling Cross-Origin Resource Sharing, and SQLx for database interaction with PostgreSQL.