辅导 data编程、讲解 SQL程序语言
Due Jul 2 by 11:59pm
Points 100
Submitting a file upload
File Types rmd and html
Available until Jul 14 at 11:59pm
:[HY[(ZZPNUTLU[
5V[H)LUL
Read this entire page twice before you get started.
The due date is July 2 at 11:59pm ET. Late submissions are accepted (with the usual penalty of
2.5% per day late) until July 14 at 11:59pm ET. No submissions are accepted after that -- not
submitting the practicum by then will make it impossible to earn a passing grade for the course.
Work on the practicum for at least three hours every day and use the time during the week prior to
the practicum to start working on it, especially the configuration of the MySQL Server and the loading
of the data. Do not wait to get started.
A gentle reminder that the average of both practicums must be above 70% to pass this course, so be
sure to complete on time and seek help right away. Do not procrastinate -- things that appear simple
often take more time than expected and, of course, programming is fraught with potholes on the road
to success. So plan accordingly. Do not wait until shortly before it is due.
The average time to complete the practicum is 15-25 hours. Do not wait to start. Seek help early.
Submit often and as soon as you have enough code that works. We will only grade the last
submission. Check your submission before you submit and after.
6]LY]PL^
In this practicum you will build a database that can be used to analyze bird strikes on aircraft. For an
existing data set from the FAA [1], you will build a logical data model, a relational schema, realize the
relational schema in MySQL/MariaDB, load data into the database, execute SQL queries, a finally
perform some simple analysis of the data.
The graphic below shows some statistics regarding bird strikes and helps frame the data in the data
file.
Use the provided time estimates for each tasks to time-box your time. Seek assistance if you spend
more time than specified on a task -- you are likely not solving the problem correctly. A key objective
is to learn how to look things up, how to navigate complex problems, and how to identify and resolve
programming errors.
3LHYUPUN6IQLJ[P]LZ
In this practicum you will learn how to:
configure cloud MySQL
connect to cloud MySQL from R in an R Notebook
implement a relational schema for an existing data set
load data from CSV files into a relational database through R
execute SQL queries against a MySQL database through R
perform simple analytics in R
identify and resolve programming errors
look up details for R, SQL, and MySQL
time-box work
-VYTH[
Complete individually.
7YLYLX\PZP[L;HZRZ
1. Read the Hints and Tips section below and go back to them often when you encounter problem.
Most problems are addressed in that section. Consult the list before contacting us for help as
you'll be able to resolve the issue more quickly.
2. Create an R Project and within that project create an R Notebook in which to do all of your work.
Place all files within the project folder and do not use absolute file paths. Embed any diagrams inthe R Notebook and be sure to submit them as files in your submission. Keep updating this
notebook as you complete tasks. Learn how to use journaling in data analysis work. Use 6.204 --
Literate Programming with R Notebooks (http://artificium.us/lessons/06.r/l-6-204-rnotebooks/l-6-204.html)
for reference. Of course, in practice, you will likely build different
programs (perhaps even using different programming language) for database creation, data
loading, and the dashboard. But here we will do it all in one R Notebook.
3. Become familiar with the problem of bird strikes on aircraft. The report in [1] provides an overview.
You should scan it to become familiar with the domain but you do not need to read it deeply.
4. Download the file BirdStrikesData.csv (https://s3.us-east2.amazonaws.com/artificium.us/datasets/BirdStrikesData-V4-SuF24.csv)
and save it locally to your
R Project folder (the same folder that contains you .Rmd and your .Rproj files) or reference it from
the URL. You may wish to create a new data file that is a subset of the full data that you use for
development so loading takes less time. This is a common strategy in practice. To download the
file, use the right mouse button and choose "Save Link As..." or a similar menu choice on your
browser. Do not click on the link as that will cause the browser to open and display the file.
Read the Hints & Tips section frequently and before posting questions.
2L`9LZV\YJLZ
7YLYLX\PZP[L3LZZVUZ
06.103 Working with Vectors and Data Frames in R (http://artificium.us/lessons/06.r/l-6-
103-vecs-and-dfs/l-6-103.html)
06.106 Import Data into R from CSV, TSV, and Excel Files
(http://artificium.us/lessons/06.r/l-6-106-load-csv-tsv-excel-files/l-6-106.html)
06.108 Loops and Iteration in R (http://artificium.us/lessons/06.r/l-6-108-loops-iteration-inr/l-6-108.html)
06.112
Basics of Text & String Processing in R (http://artificium.us/lessons/06.r/l-6-112-
text-proc/l-6-112.html)
06.121 Writing Functions in R (http://artificium.us/lessons/06.r/l-6-121-funcs-in-r/l-6-
121.html)
06.204 Literate Programming with R Notebooks (http://artificium.us/lessons/06.r/l-6-204-rnotebooks/l-6-204.html)
06.191
Debugging R Code (http://artificium.us/lessons/06.r/l-6-191-debugging/l-6-191.html)
06.301 Working with Databases in R (http://artificium.us/lessons/06.r/l-6-681-key-value-dbredis-from-r/l-6-301.html)
06.304
Configure and Connect to Cloud MySQL from R (http://artificium.us/lessons/06.r/l6-304-cloudMySQL-from-r/l-6-304.html)
06.302
Bulk Load Data from CSV into Database in R (http://artificium.us/lessons/06.r/l-6-
302-bulkload-data-into-db/l-6-302.html)
06.306 Dates in R and SQLite (http://artificium.us/lessons/06.r/l-6-306-dates-in-r-and-sql/l-6-
306.html)70.907 Stored Procedures in MySQL (http://artificium.us/lessons/70.sql/l-70-907-storedprocs-mysql/l-70-907.html)
;HZRZ
Before
you start, read all of the questions. Inspect the CSV data file that you downloaded so you are
familiar with its columns, data types, and overall structure. Assume that this database will eventually
be used for an app that can be used by pilots (of any kind of aircraft) to report wildlife incidents.
All R and SQL code blocks must be named, as shown in the example below. This is necessary so
that you can reference your code blocks in the self-evaluation rubric to be filled out at the end of the
practicum. The names of code blocks must be unique.
```{r nameOfRCodeBlock, eval = T, warning = F}
```{sql nameOfSQLCodeBlock, connection = xDB}
You may add any additional block parameters as needed.
Use functions to structure your code so that it becomes more readable and easier to develop and
debug. Use headers to segment your notebook and add explanations as to what each code block
means. Follow common coding practices and format your code so it is readable, and use functions to
break down complex code.
1. (5 pts / 2.0 hrs) Set up and configure a MySQL Server database on db4free.net
(http://db4free.net/) or any other MySQL cloud service of your choice such as
freemysqlhosting.net (https://www.freemysqlhosting.net/) , Google Cloud or AWS. Note that
you may use SQLite instead of MySQL but you will not get credit for this question nor credit for the
question below that asks you to create a stored procedure, as those are not supported in SQLite.
See the Hints below for information on db4free. Lesson 6.304 -- Configure and Connect to
Cloud MySQL from R (http://artificium.us/lessons/06.r/l-6-304-cloudMySQL-from-r/l-6-304.html)
provides some advice on connecting to these two databases.
If you use freemysqlhosting, we recommend that you pay (for the remainder of the term or the
entire year) for a 100MB upgrade (really cheap, like cost of couple cups of coffee) as otherwise
exceeding the 5MB limit will get your account suspended. You may share a subscription as it
allows five databases. Alternatively, you could split the data over multiple databases. Of course,
using a different MySQL host such as Google Cloud or Amazon AWS (or any other of your choice)
can solve this issue too, but they are a bit more difficult to set up. If you use AWS RDS you need
to pay particular attention to ensuring you set global access policies and proper security policies --
this can be quite tricky and therefore we do not recommend using AWS. We recommend that you
purchase an educational subscription to freemysqlhosting (and share it if you'd like to); it is the
easiest to set up and work with.
Both Amazon AWS and Google Cloud offer free credits, but be sure to monitor usage so you do
not exceed the free credit or are prepared to pay (they can be a bit costly, so be careful to
suspend database when not in use and delete after the Practicum has been graded).You may collaborate and work with others to set up a cloud MySQL installation, but not for the
remainder of the practicum. A cloud MySQL installation is necessary for us to run your code -- we
cannot connect to a local installation of MySQL, although you may use one for testing and
development.
2. (1 pts / 0.1 hrs) Create an R Notebook named "LastNameFirstInitial.CS5200.PractI-SuF24.Rmd"
where LastName is your last name and FirstInitial is the first letter of your first name, e.g., GilesM.
Set the title of the R Notebook to "Analysis of Wildlife Strikes to Aircraft" and the subtitle to
"Practicum I CS5200", add an author field, and set the date to "Summer Full 2024". Be sure to do
all work within an R Project (named as you wish).
3. (4 pts / 0.1 hrs) Add an R code chunk that connects to your MySQL database. Use headers for all
other questions with appropriate titles so you (and we) can navigate the notebook more easily. If
you have difficulty connecting to or setting up MySQL, then use SQLite and proceed. You can
always come back to this question and change your configuration so that you connect to MySQL.
This is the benefit of relational databases: you can easily switch between databases without
changing your code. Do not echo the code in the notebook and supress any warnings or other
messages. Add an appropriate code chunk label.
4. (30 pts / 3.5 hrs) In a single R code chunk that is not echoed (i.e., set "echo = F" for the code
chunk and suppress all messages), create the database schema described below (do not use
{sql} code chunks). Add appropriate constraints, primary key and foreign key definitions. In the
schema definitions below, primary keys are underlined and foreign keys are bolded.
A. (5 pts / 0.5 hrs) Create a table flights that stores information about flights that experienced
wildlife strikes and follows this schema:
flights (fid : integer,
date : date, originAirport : integer,
airlineName : text, aircraftType : text, isHeavy: boolean)
Make isHeavy a Boolean flag and use TRUE if the aircraft is a "heavy" aircraft, FALSE
otherwise -- this information is in the CSV. For aircraftType use the column aircraft from the
CSV. Use appropriate data types for the columns and store any date as a date type not as text
(subject to the data types your chosen database supports). If date or boolean data types are
not supported, choose another data type that will work or split the dates into month, day, and
year columns. Note that some columns contain periods so that will require special treatment in
SQL -- investigate how to deal with this common issue.
The column originAirport is a foreign key linking a flight to an airport (defined in the table
below).B. (5 pts / 0.5 hrs) Create a table that stores airports and that follows this schema:
airports (aid : integer, airportName : text, airportState : text, airportCode : text)
aid is a synthetic primary key, airportName is the name of the airport and is from the airport
column in the CSV, airportState corresponds to the airport state (the origin column) from the
data file. The airportCode should be the airport's international code, e.g., BOS for Boston or
LGA for LaGuardia. For now, set it to the default value "ZZZ" -- it is for future expansion.
C. (4 pts / 0.3 hrs) Link the flights and airports tables via the origin foreign key in flights to the
primary key aid in airports. The origin is an FK to the airport in the airports table. Update the
above table definitions for airports and flights as necessary.
D. (4 pts / 0.5 hrs) Create a lookup table called conditions defined as follows:
conditions (cid, sky_condition, explanation)
Link this lookup table to the incidents table defined below through the conditions foreign key.
This table contains the values of all sky conditions, e.g., 'Overcast'. Leave
the explanation column empty (future expansion). Use the values from the CSV.
E. (4 pts / 0.5 hrs) Create a table that stores wildlife strike incidents called incidents and that
follows this schema:
incidents (iid : integer, fid : integer, wlsize : text, impact : text, altitude : integer ≥ 0, conditions
: {...})
iid is a synthetic key. fid is a foreign key for the flight for which this strike occurred for. The
conditions column is a foreign key link to the conditions lookup table. The column wlsize is the
wildlife size from the corresponding column in the CSV. The other columns are directly from
the CSV, or, if not present in the CSV, set them to a default value for now. The column altitude
should be restricted to positive integers greater than or equal to zero using either application
logic or a CHECK constraint (if the database supports constraints; MySQL version prior to
8.0.16 do not enforce any CHECK constraints). Using a trigger is also an option, but do not
turn on triggers until all data is inserted, as it will have significant a negative performance
impact on row insertion.
F. (3 pts / 0.3 hrs) Link the incidents and flights tables via the fid foreign key in incidents to the
primary key fid in flights.
G. (2 pts / 0.3 hrs) Add one or more code chunks that are not evaluated (eval = F) when the
Notebook is knitted but can be used to test your table definitions. Add whatever test code youneed to assure yourself that your table definitions are correct.
5. (1 pts / 0.1 hrs) If you haven't yet, download the bird strikes CSV data file from the link provided
before. Place the CSV file into the same folder as your R Notebook and then, in a separate code
chunk (not echoed) load it into a dataframe called bds.raw. Do not use a path name when loading.
The default path is the local folder that contains the R Notebook when you have the R Notebook
in an R Project. Be sure to always re-open the project when returning to R Studio.
6. (20 pts / 8 hrs) Using the table definitions and the data in the dataframe bds.raw from above,
populate the tables with the data from the appropriate columns. Omit any columns from the CSV
that are not referenced in the tables. You do not need to create any additional tables. Because we
are not adding additional tables there will be (unnormalized) data and repetitions, for example for
aircraft -- that is acceptable for this practicum due to time constraints but would not be if this were
an actual analytics database project. Assume "Business" to be an airline name (it is actually a
private flight but we assume it is the airline called "Business") and store those incidents.
You may (nd should) use functions to structure your code. Be sure not to echo any code chunks
and supress messages.
Use default values where the data file does not contain values or leave empty. If there is no
airport or airline, then link to a "sentinel" airline or airport, i.e., add an "unknown" airline and airport
to the tables rather than leaving the value NULL. Assign synthetic key values as and where
needed and use them as primary keys. Whether you generate them in R code or the database is
up to you -- each has pros and cons and part of the objective of this practicum is for you to think
through such decisions.
Map the values in the data file to appropriate values in any lookup tables using reasonable rules
that you may define as necessary.
All data manipulation and importing work must occur in R. You may not modify the original
data outside of R -- that would not be reproducible work. It may be helpful to create a subset
of the data for development and testing as the full file is quite large and takes time to load.
7. (1 pts / 0.5 hr) Add code chunks that you can run and that show that the loading of the data
worked by displaying parts of each table (do not show the entire tables). Do not echo the results
of those code chunks and make sure they are eval=F so they are not included in any knitting
process.
8. (3 pts / 1 hr) Add a level two (##) header with the title "Top Airlines with Strikes" and below create
a SQL query against your database to find the top 5 airlines with the greatest number of wildlife
strike incidents. You must use an R function to execute the query. It must be a single query.
Display the airline and the number of incidents. Note that every row in the incidents tableconstitutes one "incident". Do not echo the code.
9. (10 pts / 1 hr) Add a level two (##) header with the title "Analysis by Airport". Create a SQL query
against your database to find the airports that had an above average number wildlife strike
incidents. You must use an R function to execute the query. It must be a single query. To do this,
find the number of bird strike incidents for each airport (remember that each row in the incidents
table is a single bird strike incident). Then calculate the average across all airports and from there
find those airports which had an above average number of bird strike incidents. List the names of
the top 5 airports and the number of incidents for each. Do not echo the code, only the result.
10. (8 pts / 1 hr) Add a level two (##) header with the title "Analysis by Year". Create a SQL query
against your database to find the (total) number of wildlife strikes per year. Save the result of the
query in a dataframe. You must use an R function to execute the query. It must be a single query.
Format the result with appropriate table headers using the kableExtra package. This query can
help answer the question which year has more wildlife striking aircraft than normal. Do not echo
the code, only the result.
11. (5 pts / 2 hrs) Add a level two (##) header with the title "Trend by Year". Using the dataframe from
Question 10 above, build a line chart that plots year along the x-axis versus number of the
number of strikes on the y-axis. Adorn the graph with appropriate axis labels, titles, legend, data
labels, etc. You should use the standard R plot() function; you do not need to use packages
such as ggplot, ggplot2, or plotly -- although you may, of course. This tutorial
(https://www.statmethods.net/graphs/scatterplot.html) may help you get started.
12. (10 pts / 3 hrs) Create a stored procedure in MySQL (note that if you used SQLite, then you
cannot complete this step) that updates a strike (identified by its primary key) from the database.
You may decide what you need to pass to the stored procedure to update a wildlife incident. You
must log this update in an audit log that contains the type of modification (an update), the table
that was manipulated, the time and date of removal, and the original values of the strike that was
updated. Create the "update_log" table if it does not exist.
Show (in R) that your procedure works and that the log table is updated as required.
Note that if you used SQLite rather than the required MySQL for the practicum, then you cannot
complete this question as SQLite does not support stored procedures.
13. (5 pts) Create professionally developed code that is well documented and all chunks are labeled.
/PU[ZHUK;PWZ
Ask clarifying questions in the "Practicum I QnA" channel on Teams.
If you find it helpful, draw an ERD.
Ask questions as soon as you encounter them.
While you need to look up details for functions and R, the solution cannot be found via Google.Do not spend extraordinary time on code errors; ask for help if you cannot resolve them within 30-
minutes. First through Teams and then by going to TA office hours -- the TAs will alert the
instructor if there are doubts they cannot resolve.
The TA can help you and answer questions, but they are not your personal tutors; do not rely on
them to debug your code. Code small, test often.
You may use AI assistants as needed but let us know which ones you used and for what; add
acknowledgments in your code and you must be able to explain any code you copied or
borrowed.
If you have trouble connecting, be sure to disable any firewall or anti-virus software that may be
clocking port 3306 -- or add port 3306 to the list of open ports in your firewall software
configuration.
The function dbWriteTable() is disabled for bulk loading on the MySQL cloud installation
on db4free. It does work fine for MySQL on freemysqlhosting.net and AWS RDS and for local
installations of MySQL if you allow for batch loading.
Be sure to click the activation link in the email from db4free.net after you create your database; if
you get "Access denied..." error messages then you did not activate your account.
Be sure to shut down your databases if you are not using them; otherwise you might exceed the
monthly free time. And, be sure to delete the database after the course is done or you will be
billed.
Batch loading (via dbWriteTable() ) is disabled for security reasons by default on local installations
of MySQL. Here's how to enable it: mysql - ERROR: Loading local data is disabled - this must
be enabled on both the client and server sides - Stack Overflow
(https://stackoverflow.com/questions/59993844/error-loading-local-data-is-disabled-this-must-beenabled-on-both-the-client)
. Note that you cannot enable this for db4free.net -- it does not give
you privileged access to do this.
Enable functions, procedures, and triggers on Amazon AWS RDS:
https://aws.amazon.com/premiumsupport/knowledge-center/rds-mysql-functions/
(https://aws.amazon.com/premiumsupport/knowledge-center/rds-mysql-functions/)
On AWS, if you get errors that the service is not reachable, then you need to edit the "inbound
rules" of the security group that is attached to the RDS -- add the MySQL/Aurora type and port
range 3306 with cidr 0.0.0.0/0
If you use sqldf for manipulating or querying internal data frames, be mindful of conflicts between
SQLite and MySQL; see mysql - How to use sqldf in R to manipulate local dataframes? -
Stack Overflow. (https://stackoverflow.com/questions/60117431/how-to-use-sqldf-in-r-tomanipulate-local-dataframes)
A potential issue with sqldf can occur when you connect to MySQL
or a non-SQLite database as sqldf attempts to use your existing database connection as a
backing store for its data; this will often not work due to security constraints. So, you need to add
the R code options(sqldf.driver = 'SQLite') which forces sqldf to use SQLite as its backing
store.
sqldf is very slow for querying or extracting data from a data frame as it actually copies the data
frame to an in-memory SQLite database and then runs a SQL query; so, only use sqldf is there's
no simple way to do a native R "query" with logical operations and which() and any() , e.g., use
sqldf to do grouping but not much elseIf you get errors connecting to MySQL, make sure you have the latest version of R and upgrade R
and all packages as necessary.
Using mixed upper and lower case for table names sometimes causes issues with
dbSendStatement() and dbWriteTable() when using MySQL; make all table names and attributes
names fully lower case; SQL is not case sensitive when it comes to keywords like INSERT vs
insert BUT it is when it comes to table and attribute names
Put columns that contain special character such as period (.) or have names that are keywords
into backticks, e.g., SELECT `condition` FROM incidents;
If you get a message "Can't initialize character set unknown", see
https://stackoverflow.com/questions/52613809/rmysql-error-cant-initialize-character-setunknown
(https://stackoverflow.com/questions/52613809/rmysql-error-cant-initialize-characterset-unknown)
and https://github.com/pBlueG/SA-MP-MySQL/issues/203
(https://github.com/pBlueG/SA-MP-MySQL/issues/203)
There appears to be a bug in MySQL stored procedures that contain a SELECT as the last
statement in the procedure; if you get the message "Commands out of sync; you can't run this
command now", you must use INTO with your SELECT; see
https://stackoverflow.com/questions/6583020/mysql-stored-procedure-caused-commandsout-of-sync
(https://stackoverflow.com/questions/6583020/mysql-stored-procedure-causedcommands-out-of-sync)
All
your work must be within your programs; we will run your code against one of our MySQL
servers with a blank database (or SQLite if that's what you used) and it has to run from beginning
to end; so if you did work outside of your code then we cannot reproduce your work you'll get a
grade of 0.
Before submitting, test that you code runs and your any notebooks that may be required knit in a
clean environment. So, remove all objects first by either including this code in the beginning of
your R Notebook rm(list = ls()) or by clearing your environment in R Studio with the menu item
Session/Clear Workspace.
Explain your approaches and any manipulations, omissions, deletions, or modifications of data.
Be sure to install packages within your code (but only if not installed) to ensure they get installed
when the graders run your code. Here's an elegant way to do this:
https://statsandr.com/blog/an-efficient-way-to-install-and-load-r-packages/
(https://statsandr.com/blog/an-efficient-way-to-install-and-load-r-packages/)
In R, if you want to change a global variable (one used first outside a function), then you need to
use a special assignment operator: <<- instead of <-.
Unlike MySQL and other databases, SQLite does not have support for a separate "Boolean" data
type; instead Boolean values are stored as integers, although SQLite recognizes the keyword
TRUE (1) and FALSE (0) as of version 3.23.0 but those are just synonyms for the integers values
1 (TRUE) and 0 (FALSE).
If your data frames are not written to the database when you use dbWriteTable() then check to
see if your data frame contains columns of type date -- there may be issues in converting R dates
to SQL dates; for more information on this, see Lesson 6.306 Dates in R and SQLite
(http://artificium.us/lessons/06.r/l-6-306-dates-in-r-and-sql/l-6-306.html)To find version of your database, issue this SQL meta-query from an R code chunk or via MySQL
Workbench: SELECT version()
freemysqlhosting does not support triggers and has limits on constraints.
If you are using Google Cloud or AWS MySQL (which are awesome), be sure to suspend when
not using and shut down when you are done -- you will continue to be charged and eventually
your free credits will run out.
If you use freemysqlhosting, we recommend that you pay for a 100MB upgrade (really cheap, like
cost of lunch or dinner out) as otherwise exceeding the 5MB limit may get your account
suspended. Alternatively, you could split the data over multiple databases, or you could reduce
the size of the CSV so that the database is below 5MB. You may share a single subscription
among several students as it allows for up to five independent databases. You may not share the
database, of course.
4`:83*SV\K:LY]LYZ
Amazon RDS Free Tier | Cloud Relational Database | Amazon Web Services
(https://aws.amazon.com/rds/free/)
db4free.net - MySQL Database (https://www.db4free.net/)
Hosting with PHP, MySQL and cPanel (freehosting.host) (https://freehosting.host/)
Hosting with PHP, MySQL (AwardSpace.com) (https://www.awardspace.com/)
0UZWLJ[PUN3HYNL*:=-PSLZ
In the video tutorial below, Khoury Boston's Prof. Feinberg demonstrates how to find the path of a file
and how to inspect large CSV files prior to loading into R or another programming
environment. Follow the steps as you watch the tutorial. Stop the tutorial as needed. This
demonstration presumes that you have MacOS or use a Linux/Unix environment.
0:00 / 5:59
:\ITPZZPVU+L[HPSZ
Before submitting your code, complete the self-evaluation rubric (separate "assignment"; see
Canvas).1. Provide in your R Notebook:
A. name and email
B. table creation SQL for MySQL/MariaDB (or SQLite)
C. results of queries, visualizations, computations to show that your code works as expected
D. clear explanations of your code that is decomposed into chunks and preceded by headers
2. Complete the self-evaluation rubric: [30 min] COMPLETE: Practicum I / Self-Evaluation
(https://northeastern.instructure.com/courses/180750/assignments/2248391?wrap=1)
3. Submit the .Rmd source file of your R Notebook. The code must run from start to end, so be sure
to test carefully, load any required libraries, and ensure that your chunks run sequentially from
start to end.
4. Submit a knitted HTML of your Rmd; the HTML must be a compact page, so pay attention to
formatting, headers, and how much data you print. If you have trouble knitting on your local
installation of R Studio, consider using the cloud version of R Studio to do the knitting. Not
submitting a knitted file results in a loss of 5 points. Submitting a poorly formatted HTML results in
a loss up to 5 points.
5. All your work must be within your R Notebook; during the demonstration, we will ask you to run
your R Notebook against one of our MySQL servers with a blank database and it has to run from
beginning to end; so if you did work outside of your R Notebook (e.g., in Excel or MySQL
Workbench) then we won't be able to reproduce your work and you will get a grade of 0.
6. Your code has to run, obviously, but it also has to run somewhat efficiently... if everyone else's
code runs in 10-30 minutes but yours takes several hours then clearly is due to poor programming
and not due to the inherent complexity of the problem... follow common coding strategies for
writing efficient code such as factoring out invariants from loops, not calling functions repeatedly,
pre-allocating memory, not copying objects needlessly, not calling expensive functions when
simpler ones will do (e.g., call substring() instead of doing regular expressions), use which() when
searching and don't use sqldf, and so forth. These practices are not specific to R, although there
are R specific performance issues, but those are less likely to be a concern here.
9LX\PYLK5L_[:[LWZ
Check your submission to ensure the correct files have been submitted
Complete and submit the self-evaluation rubric
Schedule demo