Final Projects

Purpose:

These projects are intended to:

• Explore cross-platform development, supporting systems that use more than one plaform to carry out their activities. We will focus mostly on combinations of Windows and Linux platforms.
• Learn new technologies that you probably have not been exposed to in your program of study. You will be given some initial references but will be expected to do independent work to develop a working knowledge of the specific technology you've chosen.
• Develop a portfolio project that will interest interviewers and give you the opportunity to showcase your skills and interests.

Project descriptions from 2015

You will pick one of the Projects listed below to implement, either individually, or with one or two other students, and will make three presentations for your project:

• Technology Overview:

  Discuss your project goals and the technology/platform and frameworks you will be using in a tutorial manner. The idea is that you will explain to the rest of the class how your selected technology works and how you will use it to implement some interesting and useful functionality.

• Probing Examples:

  You will present a series of code demonstrations that illustrate what you have learned about your choosen technolgy/platform. These should help the class understand how the technology works and should also move you toward the implementation of your Final Project.

• Final Project Presentation:

  Here you quicly summarize the main points of your first two presentations and then describe in detail the design and implementation of your project along with demonstrations of what it can do.

Project List:

1. Tiny HTTP Client and Server (HTTP-CS):

   The idea:

   Building block for C++ message-passing communication channels, servers, and other internet enabled programs.

   The goal of this project is to implement small and simple components, HTTPClient and HTTPServer, used to build message passing communication channels in C++ on both Windows and Linux. Those can be used to communicate between any two platforms that support native code, e.g., Windows, Linux, Unix, Macs, etc. The most important measure of success for this project is to create a small code base to efficiently send messages with very low complexity for the using applications.

   This project will use sockets (you may use a sockets package found in the Repository) to send HTTP style messages. Each message has a header consisting of text lines - the first is a command, and subsequent lines are attributes that describe the message with key:value pairs, e.g., content-length:543 implies that the header is followed by a block of 543 bytes of data. The HTTPClient and HTTPServer components will be developed for both Windows and Linux platforms. Another measure of success is the ratio of common code to that which is unique for each platform. Ideally that ratio should be large.

   You may re-implement one of your class projects that used WCF or another socket implementation. Alternately, you may collaborate with one or two other students working on a project that requires message-passing communication.

   Links:

   HTTP Made Really Easy, Sockets-Windows
   Top
2. Cross-Platform Library (CP-LIB):

   The idea:

   Platform specific libraries with common interfaces to support common code across multiple platforms.

   This project extends an existing C++ library of low-level program support components for both Windows and Linux. The idea is that each component provides the same interface on all supported platforms, but uses the operating system APIs to implement the interfaces. The current library has classes to manipulate files and directories for both Windows and Linux. To that this project will add, for both Windows and Linux:

   • FileSystem library (already complete for both Windows and Linux - see Repository).
   • Sockets library, probably based on the library provided in Handouts/Repository. This will focus mostly on porting the existing Windows library to Linux and testing the result.
   • Process library to create, start, and communicate with new processes. This will use the Windows and Linux APIs to implement a Process class with some of the capability of the .Net Process class.
   • Thread Pool, using C++11 threading and locking constructs. This will involve creating a specified number of threads that block on a thread-safe blocking queue waiting to dequeue lambdas that define the work to be done¹.
   • Communications library, based on collaborating with students working on the preceeding project.
   • Graphical User Interface library, based on collaborating with students working on the next project.

   Links:

   FileSystem-Windows, FileSystem-Linux, Sockets-Windows, Message-Passing WCF Comm Prototype - SMA Fall 2015
   Top
3. Cross-Platform GUI using Chrome and Tiny HTTP Server (CP-GUI):

   The idea:

   GUI built from Chrome using HTML5 and Tiny HTTPServer that will run on Windows and Linux with no changes other than recompiling the C++ HTTPServer.

   The .Net framework on Windows provides an elegant UI framework call Windows Presentation Foundation (WPF). On Linux there are a lot of GUI frameworks² that work well but don't provide the declarative programming style that WCF exposes through Xaml. The intent of this project is to provide a new alternative that works for Windows, Linux, and Macs, based on use of the Chrome browser and one or more HTML5 pages to support declarative layout of the user interface.

   Each application that uses this new framework will host a tiny HTTPServer, as developed in the first project, and, on startup will start Chrome with an appropriate HTML5 page and Javascript library. Communication between the application and chrome is based on Ajax calls, e.g., a button click will send a message to the application to do something that usually will not result in downloading a new page to Chrome. The application performs the requested action and returns any information that needs to be displayed, probably using JSON or XML.

   The result is that we can build cross-platform applications using the support libraries, developed in the preceeding project, application code that is common to both platforms, and GUI code that is also common to both platfroms.

   Links:

   HTML5 Introduction, Ajax Tutorial, JavaScript Tutorial
   Top
4. REST Web Services as Program Components (REST):

   The idea:

   Modern version of Distributed COM - build systems from components found on the local network.

   REpresentational State Transform (REST) services are web services that use the HTTP commands (Get, Post, Put, Delete, ...) as verbs that each describe an action applied to objects that are identified by a url. Unlike conventional web services REST does not use an embedded infrastructure like Simple Object Access Protocol (SOAP). It's messages are passed in clear text unless transmitted over SSL. REST applications are usually simpler and faster than conventional web services.

   This project explores the decomposition of applications into a set of REST services and a small amount of glue code to complete the application. You might think of this as a UI application that delegates all of its processing to this set of REST services.

   This allows applications to share a lot of code with other applications that may be remotely located. Think of the service collection as a repository of functionality that may be used across a federation of servers in some enterprise application.

   Links:

   Representational State Transfer - Wikipedia, What is REST?, REST Tutorial, REST Tutorial, Asp.Net Web API, First Web API
   Top
5. Virtual Display System (VDS):

   The idea:

   Build an interface for collaboration, sharing documents, code, webcams, and sketchpad.

   In a Software Modeling & Analysis final project (Fall 2021) we explored the use of a large display as a medium for collaboration in a Software Development Server Federation. This project implements a prototype for this kind of display system.

   VDS is an application that drives a large display³ for use in collaboration systems. The purpose of this project is to develop a framework and rendering process to display simultaneously web-cam windows, document windows, drawing surfaces, directory views, and information derived from queries into NoSql Databases or some repository.

   For this project the displayed resources would be source code text, pdf files, sketch pads, skype windows, all drawn from a local repository. It could be implemented as a browser displaying an HTML5 page that supports adding and removing elements, changing view sizes and locations, and saving a current session in some persistant format like XML.

   Links:

   HTML5 Introduction, JavaScript Tutorial, JavaScript Tutorial - the details
   Top
6. Virtual Repository Server (VSERV):

   The idea:

   Build server template that is clonable and supports data replication - used by teams working on large projects.

   The Virtual Servers defined for this project have three properties:

   • Support a clone operation that builds a clone of an existing server on any Windows or Linux platform that invokes the source server's clone operation. The invoker can request that some subset of the source server's content be replicated on the target server.
   • Use a message-passing communication system based on the Tiny HTTPClient and HTTPServer from the first project.
   • Implement a message dispatcher mediator that makes adding new server functionality exceptionally easy.

   One obvious application of Virtual Servers is in Software Collaboration Systems. A project might have Repository, TestHarness, and Collaboration servers. Any one of the teams using the collaboration system may wish to replicate a Repository or TestHarness for their own team activities for initial development, before checking in software to the Project Repository.

   Links:

   Message-Passing Server Blog, Demo Code
   Top
7. Personal Website using the MEAN Stack (MEAN):

   The idea:

   Build a portfolio project to demonstrate at job interviews using open-source technologies.

   There is currently a lot of interest in using the MongoDB, ExpressJS, AngularJS, and NodeJS (MEAN) stack for developing responsive, scalable websites.

   In this project you will explore these technologies by implementing a personal website that has the following features:

   • Resume Page
   • Repository page with descriptions and links to your project code submitted during your program and/or developed out of personal interest. This should include a mechanism to view individual pages of source code.
   • A story page, telling your story with well formated text and pictures, e.g., your Undergraduate Program, your Program at Syracuse University, your work experience, etc.
   • Other features that use specific properties of the MEAN stack.

   You could subscribe to a hosting service and provide a link on your resume for prospective employers to view.

   Links:

   MEAN Development in 9 Parts - CodeProject
   Top
8. Visio-Style Drawing Tool (VS-DT):

   The idea:

   Create a subset of Visio style functionality - useful for building distributed collaboration systems.

   Develop a drawing tool that provides a (small) subset of the facilities of Visio, but is easier to use. For example:

   • Templates for specific visual objects like classes, packages, activity diagrams, connectors, etc.
   • The ability to move visual objects and/or the break points for connecting lines, i.e., the places where a connection line forms a right angle.
   • Connection points on visual objects that support maintaining the connections as a visual object is moved in the diagram.
   • Annotating visual objects with text and dropping text on other parts of a diagram.
   • You might, time permitting, implement a communication channel that allows remote collaboration using the drawing tool.

   There are two interesting ways to implement this tool:

   • Using HTML5 & Javascript. This would require you to implement a Javascript object model that wrapped the various visual objects.
   • Using Cinder & C++11. Cinder is a C++ framework that wraps OpenGL, making it significantly easier to use. Here, you would implement a C++ object model for visual components.

   This tool has an obvious application to the Visual Display System.

   Links:

   HTML5 Introduction, JavaScript Tutorial, JavaScript Tutorial - the details
   OpenGL in Cinder, Cinder - C++ Library that wraps OpenGL
   Top
9. Graph Visualization (G-VIZ):

   The idea:

   Develop means to visualize large directed graphs - perhaps from dependency relationships in large software systems.

   Graphs - collectons of vertices connected with possibly directed edges - are very useful data structures for capturing dependency relationships, geographic relationships, corporate and team structures, etc.

   For some applications the graphs may be very large, e.g., dependencies between packages in a large software system. The easiest way to extract useful information from large graphs is to view them in some well organized structure, perhaps on a computer screen. However, when the graphs are large it is not obvious how to organize them properly, e.g., place vertices in a view in which there aren't a lot of crossing edges. The larger the graph the more difficult it is to lay out the graph manually, e.g., by drag and drop.

   This project focuses on routing and displaying possibly large graphs by simulating a physical system in which each vertex has a repulsive force on every other vertex, perhaps inverse square law, tending to push apart the vertices, and edges have a restraining force pulling the two end-point vertices together, thus preventing infinite expansion of the graph.

   You would also need damping forces, proportional to the speed of motion of the vertices, to prevent oscillation in their motions. The way this routing algorithm behaves is determined by the constants used for the inverse square law repulsions, linear attractions, and linear retarding forces.

   You will find a C++ graph class in the repository. So using Cinder to render the graphs would be a fairly direct way to approach the project implementation. Alternately you could port the Graph class to C#⁵ and use WPF for rendering.

   Links:

   C++ Graph, OpenGL in Cinder, Cinder - C++ Library that wraps OpenGL
   C# Graph, WPF Tutorial
   Top
10. Software Visualization (SW-VIZ):

    The idea:

    Using Graph Visualization (preceding project) develop means to explore large software systems.

    This project depends on the results of the preceeding project. Here you build the mechanics to determine dependency relationships between packages, and use that information to draw a dependency graph, where each vertex is associated with metadata that describes its package.

    This supports traversal and exploration of large software systems. It could be very useful in a code repository for QA activities and for importing large projects into an existing repository.

    Here all of the package information, including child dependency relationships is stored in a NoSql Database. We build one of those last semester in CSE681 - Software Modeling and Analysis in Project #2. You will find my implementation of that project in the Repository.

    Links:

    C# NoSqlDb - SMA Project #2, Fall 15, NoSqlDb Blog
    Top
11. Cross-Platform Apps using Xamarin (XAMAR):

    The idea:

    Build portfolio project that demonstrates (you know) how to build cross-platform mobile apps.

    Microsoft has released, in Visual Studio 2015, functionality for building applications for several different platforms, i.e., Windows, Android, and iOS. In this project you will build application(s) that run in at least two of those platforms.

    One interesting possibility would be to collaborate with a team building a REST web service, Virtual Display System, or Personal MEAN Website. Alternately you could build an application that merged information from twitter and facebook.

    Links:

    Xamarin with Visual Studio, Xamarin - Wikipedia
    
    Top
12. Directory Synchronization using GO Language (GO):

    The idea:

    Explore using "classes" in a powerful language that doesn't have classes.

    GO is an interesting new language developed by Google engineers. Unfortunately it does not support classes, but does have many interesting and powerful facilities, built in concurrency with coroutines, interprocess communication, and a built in web server - sort of like the C Language on steriods.

    In this project you implement a directory synchronizer using GO. Directory synchronizers are used to:

    • Update existing files in the target directory from newer files in a source directory on another machine.
    • Optionally it will also copy files from the source directory that don't exist on the target machine.

    This will give you the opportunity to explore the way communication channels are used, how concurrency works, and the ease of use of the GO syntax.

    Links:

    Go Programming - golang.org, Go - Wikipedia
    Top
13. Remote Data Acquisition and Visualiation using NodeJS (NODE):

    The idea:

    Explore a new and popular technology that uses server-side JavaScript to build high performance programs.

    NodeJS is a Javascript framework that focuses on spawning activities on a remote server. The NodeJS framework is based on the Chrome V8 Javascript engine and has a hosting process that allows Javascript applications to run in an executable outside the usually browser framework. It is based on a Single Threaded Apartment model⁵ that reads messages out of a queue and executes the message's request on a single thread. That has some interesting performance implications.

    A lot of environmental sensing systems use remote sensors that communicate with a central server to capture a stream of values about environmental variables, e.g., heat, acidity, chemical composition, etc. and a NodeJS based system would be ideal for managing that sensed data.

    Doing that will probably be impractical for a project in this class, but we could substitue data streams gathered from social media or simulated environmental models.

    Links:

    Node.js home site, Node.js - Wikipedia
    Top
14. Cloud Computing (CLOUD)

    The idea:

    Either set-up an open-source private cloud to learn how those things work, or use an existing technology like Azure or AWS to build a portfolio project.

    Use the open-source Ubuntu Cloud which wraps OpenStack in a Ubuntu wrapper, or OpenStack Cloud directly to set up a demo cloud and develop a simple demo application. Alternately use Microsoft Azure or Amazon AWS via a developer account to set up and explore a cloud application.

    Another interesting possibility is to use Node.js to build a private cloud.

    Links:

    What is Cloud Computing - Amazon Web Services (AWS)
    Ubuntu Cloud
    Open Stack Cloud
    Microsoft Azure - Microsoft
    
    Top

References:

Footnotes:

1. This will be discussed in class.
2. Ultimate++, CodeBlocks, wxWidgets, Qt, GTK+, ...
3. That might be a large touch screen monitor, large screen TV, or in the future, wall size displays.
4. Another alternative would be to use C++/CLI and WCF for the rendering, since C++/CLI code can interact with native code like the existing Graph class.
5. STAs are used in the COM technology and will be discussed in class (this comment does not imply that you have to use COM in this project).

What you need to do and know:

1. Know how to use the C++11 language and standard libraries.
2. Have Visual Studio 2015 installed on your machine.
3. Set up a virtual machine and a Linux distribution. I will be using VMware Player and Ubuntu.
4. Install g++ version 5.3 or CLang 3.3. We'll discuss this in class.
5. Learn the Microsoft COM technology, as discssed in class.