CMPT course代做、代做C/C++语言、C++编程调试、代写data留学生

日期：2020-08-15 11:07

CourSys - Project: the Polyglot

Project: the Polyglot

This is project is to be completed individually.

As usual, you should clearly cite the source of any code (or other content) you use from outside sources.

Project Requirements

The goal of this project is to build a single system that uses multiple languages to do its work.

It is very difficult to quantify the “size” of a project, but it should be enough to justify marks for 26% of a 3rd year CMPT course. In particular for

this project, you should have:

several pieces of interacting functionality (which give us the excuse to use multiple languages);

overall complexity that leads to a thousand to several thousand lines of code (while also noting that lines of code is a horrible way to measure

complexity of software);

complexity added by the technical challenge of getting multiple languages to work together;

a system that can be easily deployed and actually works.

A couple of possible topics for the project can be found on the project ideas page. You do not have to choose from those ideas and are free to

choose any topic if it meets the requirements specified below.

Language Requirements

You project must be implemented using three different languages. The focus of the project will be cross-language implementations and

communicating between languages. Some restrictions on your language choices:

At least one “systems” language (like C, C++, Go, Rust).

At least one “scripting” language (like Bash, JavaScript, Julia, Perl, PHP, Python, R, Tcl).

C and C++ count as one language.

Only programming languages count toward your language count (e.g. not SQL, HTML, CSS, etc).

Languages should be reasonably appropriate to the work done with them.

It is expected that you write some code in each of the three languages, but not that you write an equal amount in each language. It is reasonable to

have one language that is used fairly little (possibly just a little code to connect a library from that language), and possibly another that is a relatively

minor part of the system.

Cross-Language Communication

You must use two different ways to communicate between languages your languages. These might include:

A foreign function interface (https://en.wikipedia.org/wiki/Foreign_function_interface) where you can somehow call a function from one language

in another. If you search for “call language1 function from language2”, you'll probably find something (if it exists). See also

SWIG (http://www.swig.org/) which helps call C/C++ from many languages.

A message queue such as RabbitMQ (https://www.rabbitmq.com/) or ZeroMQ (https://zeromq.org/) . The RabbitMQ

tutorials (https://www.rabbitmq.com/getstarted.html) give good RPC (remote procedure call) examples in many languages: you can use one

language as the client and the other as the server.

8/12/2020 CourSys - Project: the Polyglot

https://coursys.sfu.ca/2020su-cmpt-383-d1/pages/Project 2/3

Create an RPC (XML-RPC or REST) server in one language and make a request to it from another. You can probably find an XML-RPC or REST

library for either language and write relatively little code to connect them to your function/function call.

A compiler toolchain that will compile both languages and let you call one from the other, like the GraalVM polyglot

features (https://www.graalvm.org/docs/reference-manual/polyglot/) or the various languages that compile to the

JVM (https://en.wikipedia.org/wiki/List_of_JVM_languages) .

Run the other language's code as an executable (exec (https://linux.die.net/man/3/exec) and friends, or often a “system” function in many

languages) and capture its output (stdout) into a string. Or have it write a temporary file and read it from the other program.

Implementation and Deployment

Your code must be in a repository on the CS GitLab server (https://csil-git1.cs.surrey.sfu.ca/) . Your final submission will be a tag in this repository

that we will check out.

We need to be able to run your system to test it. Add the instructor and TAs as “developers” on your repository: ggbaker, amutasim, mshojayi. [On

your project page: Settings → Members → Invite]

We have provided you with a template for the project (https://csil-git1.cs.surrey.sfu.ca/ggbaker/383-project) that contains (mostly commented-out)

setup for running code in many languages in a virtual machine. You can modify the setup recipe (cookbooks/polyglot/recipes/default.rb)

to install whatever tools you need so your system can run.

By the time you're done, starting the VM (with vagrant up) should get your system into a runnable state. You may have a few components that

need to be started by hand (like an RPC server). That is fine, but only one or two, and make sure they are clearly documented in your project

summary (described below).

See the Project Deployment page for more information on working with the virtual machine and Chef recipes.

Project Summary

In your project repository, include a file cmpt383.txt or cmpt383.md and briefly summarize:

What is the overall goal of the project (i.e. what does it do, or what problem is it solving)?

Which languages did you use, and what parts of the system are implemented in each?

What methods did you use to communicate between languages?

Exactly what steps should be taken to get the project working, after getting your code? [This should start with vagrant up and can include one or

two commands to start components after that.]

What features should we be looking for when marking your project?

The purpose of this is not to make you write an essay, just to guide the marking so we don't miss anything important. (There will be many projects,

and the TAs are human.)

Marking

The marking scheme will include marks for: [These may change, but will give an idea of what we're looking for.]

Problem: Is the problem you are solving interesting and appropriate to a polyglot system?

Languages: Three appropriate languages have been used meeting the requirements of the project.

Cross-Language Communication: Two different methods to communicate between languages have been used appropriately.

Difficulty: The project includes features that required non-trivial implementations or techniques.

8/12/2020 CourSys - Project: the Polyglot

https://coursys.sfu.ca/2020su-cmpt-383-d1/pages/Project 3/3

Extras: The project includes interesting features, or uses techniques that go beyond the minimum requirements.

Submitting

Create a Git tag (named final or similar) in your project repository:

git tag final

git push origin --tags

Make sure you add the instructor and TAs as “developers” on your repository: ggbaker, amutasim, mshojayi.

Submit a link to that tag in your repository through CourSys for the Project activity.

Updated Tue Aug. 04 2020, 19:43 by ggbaker.