| Number |
Project Title |
Category |
| Project #1 |
Code Exercises
Start learning C++, Rust, C#, Python and/or prepare for coding interviews.
CppBasicDemos.html,
STR.html,
CppUtilities.html
exercism.io,
utdallas.edu,
cplusplu.com,
edabit.com
interviewbit.com,
leetcode.com,
hackerrank.com,
codeforces.com,
educative.io
|
Build Coding skills |
| Project #2 |
Improve the design and implementation of one of your class Projects.
The idea:
Develop a professional quality product that you will be proud
to discuss during an interview.
See DesignProcess.html for a way to do that.
|
Portfolio Project |
| Project #3 |
Build a Graph class in Rust or C#
Use an existing C++ design as the basis
for a C# graph class.
Strengthen skills with both languages.
|
Improve code skills |
| Project #4 |
Build tool to analyze web page link dependencies
Find dependencies between a specified set of web pages by storing, in a map, page name as key,
with a list of links to other files in the set as value. Write code to invert the list to track
incoming links.
This would be quite useful for anyone maintaining a medium to large web site.
|
Improve code skills |
| Project #4 |
Audible Thread Traces
The idea:
Write code to wrap a lock that emits one tone when locking and
another when unlocking.
If the tones are different for each thread, then the tone sequence
may help you detect thread convoys waiting for locks.
Build audible trace library to support multi-thread debugging. When
a thread is created, the code registers it with a tone manager so that
each thread gets its own pair of tones. The library provides the tone
manager and lock wrapper.
Developers can then install the audibles for each thread of interest.
|
Research Project |
| Project #5 |
Process management class(es) for Windows and Linux
The Idea:
Provide a class or classes that manage creation of, and communication with,
processes for both Windows and Linux.
Hide platform details (rather different for Win and Lin) behind a simple class
interface, modeled after the .Net Process class.
|
Portfolio Project |
| Project #6 |
C++ Serialization and DeSerialization
The idea:
Save and restore the state of an object to a file using XML or JSON as the persisted representation.
Serialize using the insertion operator, operator<<, and de-serialize using the
extraction operator, operator>>. You should probably provide a base class or
template policy for persistance, so it is easy to add persistance to an existing class.
|
Build C++ skills |
| Project #7 |
Graph Visualization in JavaScript
The idea:
Build a vertex placement router to display graphs with a minimum of
crossing edges, keeping related vertices together.
Directed graphs are great for capturing relationships, e.g., dependencies between
packages in a large software library. It would be useful to visualize the
graph structure in a two-dimensional plane, to aid interpretation of its relationships.
The problem is, if we start with some random placement of graph vertices, we
probably will have a tangled mess of edges, obscuring the information we want.
This project will build a vertex placement router to spread out the graph
in some visually effective way. We will use simulated forces to effect this,
e.g., vertices repel each other, with force decreasing with distance,
and edges attract the two vertices on either end, with force that increases
with distance. That spreads out the graph, but tries to keep connected edges close to
each other.
Here's a demo from an
existing JavaScript library that does this.
This project builds code to read input vertexs and
edges from an XML or JSON store and calls the demo code to display. It also
provides editing facilities and the ability to save edited graphs.
It would be nice to add an additional repulsive force between a mouse location
and all the nodes, with the force decreasing with distance between mouse and each vertex.
That causes the graph to spread out in the vacinity of the current mouse location.
|
Portfolio Project |
| Project #8 |
Remote Directory Synchronization with WPF and WCF
The idea:
Load up your laptop with all the things you just worked on in your
production desktop machine.
Directory synchronization is the process of copying some or all contents
from one directory to another, where one of the directories is local and
one remote.
In this project, synchronization does not happen automatically, but only
when the user makes a specific request. Also, it will only synchronize
one directory on either end. Attempting to synchronize directory trees
is a recipe for, possibly disasterous, unexpected results.
There are several synchronization policies to consider:
-
Overwrite older files on one end with newer files of the same name.
-
Copy files from one end that do not exist on the other.
-
Transfer only files that match one or more patterns.
-
Transfer both ways or only one.
-
Support undo by moving originals of affected files to a temporary directory.
-
Show the changes, using file lists, and wait for confirmation to proceed.
This project is a great way to get experience with the C# Windows Communication
Foundation (WCF) and Windows Presentation Foundation (WPF).
|
Build .Net Skills |
| Project #9 |
Repository using Pluggable Components
The idea:
Build a cross-platform code and document repository that uses pluggable components to define core Repository services.
The goal of this project is to support management of code and documents using pluggable components for:
-
Storage:
The mechanics for managing directories and placement of files. Means for identifying the root of dependency chains,
identifying Systems, Modules, and Packages. Are categories used? Are they based on namespaces?
-
Dependency Information:
How dependency information is stored and accessed, e.g., with metadata XML files or with a NoSql database.
-
Versioning:
How are versions tracked? How does a user explore the version sequence of a specified package?
-
Ownership:
Are packages owned by a single developer? by a group? by any registered Repository user?
-
Checkin and Checkout Process:
How are open (incomplete) checkins and closed (complete) checkins identified and managed.
-
Browsing:
What kind of information is supplyed to the user to browse the Repository structure. This is related to how
storage is managed.
-
Building:
When and how packages are built into libraries. How are Graphical User Interface (GUI) codes handled.
How are codes from different languages handled.
Components will be defined using interfaces and object factories. There needs to be a component installation interface
that allows a component to register with, and be activated by, the Repository. Since some of these services need to
use other services, there needs to be a way for them to communicate. One way is to use function call interfaces, but that
means that every component may need to know the interfaces of many other components. That isn't a good idea as it
promotes a very tight coupling between components.
One nice solution to this problem is to use message-passing communcation between components, as well as between the
Repository and its Clients. This way each component has to support a "PostMessage(Message)" interface where
the parameters of the call are encoded into the body of the message. The message has a "from" and "to" property
so that the Repository's message dispatcher knows where to send the message, and the message recipient knows where to
send a reply. Yes, you can support properties in C++.
One interesting question is how the Repository will be hosted. Here some options:
- C++ Process
-
Web interface using the MEAN stack. Here, MEAN stands for MongoDB, Express.js, Angular.js, and Node.js.
- Asp.Net MVC
|
Portfolio Project |
| Project #10 |
Review C++ Asynchronous Message-passing Communication Channel
The idea:
Asynchronous message passing communication is used in several of these projects. Here, we are not
building new code, but looking carefully at the existing code for
CppCommWithFileXfer.
The pay-off for working on this project is to understand some interesting ideas about communication
using socket-based channels, and get a quick start on one of the other projects in this list that
use Asynchronous Message-Passing Communication (AMPC).
Traditional message-based communication, e.g., HTTP, provides a static conversation between two endpoints.
One makes a request and waits for a reply from the other. In asynchronous message passing, the communication
pattern is more of a conversation. Multiple endpoints can participate, with each sending messages without
waiting for a reply. If another endpoint wants to reply, it simply sends back a message whenever it is ready
to do so.
It helps a lot to understand that the design is very flow-oriented. We aren't focused on specific
transactions, but rather on a sustained sequence of messages.
Resources: BlogMessagePassingComm.html
|
Portfolio Project
|
| Project #11 |
C++ Testharness using Process Pool
The idea:
This project is similar in function to SMA's Project #4, Fall 2016, and OOD's Project #4, Fall 2018. It is
implemented in C++, using a process pool to enable execution of libraries in isolation, instead of using C# and .Net AppDomains.
It will still support high performance execution, but also enables testing of libraries from different technologies, e.g., C++, C#, and Java.
If you completed this as a class project, then polish it for interview discussions.
Otherwise, this will be a great chance to build C++ muscle.
Build Test Harness server using a Process pool so each test runs in its own process, without
creating an excessive number of processes. Could use socket-based message passing for IPC.
Another alternative would use shared memory and placement new to share a BlockingQueue.
The goal of this project is to support testing of more than one type of code. It does this by defining a base process class
that supports process creation and communication with the main TestHarness process. Derived classes are defined to support
a particular type of code execution, e.g., managed C# or Java code, or native C and C++ code.
This project will use C++ sockets to build a message-passing communication system, and C++ code to develop the TestHarness,
Process class for loading and executing C and C++ library code, and a demonstration client.
The process class for testing C# code will be written in C++, but is intended to support starting and communicating with
a process written in C# that loads C# libraries, and may use a C++\CLI wrapper to communicate with
the Testharness.
The process class for testing Java code will be written in C++, but is intended to support starting and communicating
with a process written in Java, that loads Java libraries and will use Java sockets to communicate with the Testharness.
|
Portfolio Project
|
| Project #12 |
C++ Tiny HTTP Web Server and HTTP Client
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 will find a prototype for HttpServer here.
Since the prototype does a lot of the implementation for windows, you will be expected to extend that in one
or more of the following ways:
- port to linux - already done, but needs some additional testing (I don't know of any bugs, but ...)
- interoperate with java which uses the Apache HttpClient and HttpServer components
- Use as the basis for supporting microservices
Note: The prototype server uses a single-threaded apartment model, which works fine for asynchronous
communication, but does not for synchronous communication like standard HTTP.
The issue is that when making synchronous calls the caller waits for a response. So you have
to either simply send an acknowledgement, before handling request, or else use a multi-threaded apartment model for the
server.
|
Portfolio Project |
| Project #13 |
Build a cross-platform GUI using Tiny HttpServer
The idea:
GUI built from Chrome using HTML5, Ajax, 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 called Windows Presentation Foundation (WPF).
On Linux there are a lot of GUI frameworks2 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, Ajax protocols, 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 previous 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 another
of these projects, application code that is common to both platforms, and GUI code that is also common to
both platfroms.
Links:
|
Portfolio Project |
| Project #14 |
Review C++ Rule-Based Parser
The idea:
Rule-based parsing of source code is used in several of these projects. Here, we are not
building new code, but looking carefully at the existing code for
CppParser.
CppParser code is a subset of the CppCodeAnalyzer project, using rule-based parser
with rules and actions that store and manipulate information in a repository.
This code simply analyzes one or more files and displays an Abstract Syntax Tree (AST) for each
file.
|
Build C++ skills |
| Project #15 |
Build C++ Code Checker
The idea:
Check code for Liskov Substitution errors and more, e.g., important issues that
compilers may not report.
The project is very similar to the CppCodeAnalyzer project, using rule-based parser
with rules and actions that store and manipulate information in a repository.
Here, we look for:
-
Base classes without virtual destructors - potential incomplete destruction
-
Overloading across class scopes - hiding
-
Overloading virtual functions - hiding
-
using virtual inheritance - always a bad idea in my opinion
-
Failure to provide Prologue comments
-
Failure to provide construction test
-
Providing copy and assignment operations when you shouldn't - bases and members have correct
copy and assignment semantics, e.g., primitive types and STL containers.
-
Not providing copy and assignment operations when you should - pointer members or members with
unknown copy and assignment semantics.
|
Build C++ skills |
| Project #16 |
Platform Tools - build platform (Windows, Linux) wrapper libraries
The idea:
Build platform specific libraries, e.g., Process, Sockets, Shared Memory,.., with common interfaces
for each platform 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 FileSystem-Windows).
It would be interesting to reimplement based on std::FileSystem (C++17 : Microsoft C++ supports an experimental version).
That has an interface based on directory_entry and iterators, which is harder to use than my FileSystem-Windows. I used essentially
the same design as the .Net System.IO classes.
-
Sockets library, based on the library provided in the Sockets 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 (already complete for Windows - See Repository, this may run on Linux as-is, but needs testing),
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
done1.
-
Process Pool, supports spawning a fixed number of processes that communicate with a mother process to get
tasks to run, with the added benefit of process isolation.
-
Communications library, perhaps 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:
|
Portfolio Project |
| Project #17 |
MicroServices
The idea:
Compose programs from small service components with message-passing communication.
Microservices are small, self-contained, building blocks used to create larger systems. The
application aggregates a number of services to implement as much of its functionality as is
practical. The application code instantiates services it intends to use and communicates with
them using messages.
If the services reside in seperate processes, then the design uses socket-based
asynchronous messaging with HTTP style messages. If a service resides in the same process
as the application code, then messages are sent directly to the receiver's queue.
Application design focuses on selecting a set of services and configuring messages to
support application activities.
This project, of course, will have to build an initial set of services, based on a specified
service architecture.
You could select a modestly complex project and implement with services, as described above,
perhaps building a directory synchronizer. Alternately, you could join a team that was building
a TestHarness or Repository and implement that with microservices.
Links:
|
Portfolio Project
|
| Project #18 |
Program Animation
The idea:
Trace data flow and control in a program while executing.
Perhaps the most straight-forward way to implement this is to log
activities to a structured file, and, after execution, run another
program that displays the flow and control.
That entails building an annotator that places logging statements in
all, or a specified subset of program methods and functions. That in-turn requires
parsing the analyzed code to find the beginning of methods and functions to
place the logger statements.
You might also want to capture values of input parameters, but that
requires a significant amount of parsing effort - doable, but perhaps best left
to Version 2.
The display program reads the log file, builds a function call graph and plots that
in a GUI window. Each function log statement gets interpreted as a high-lighted
function vertex in the call graph, and as each log statement is processed we see
the evolution of the program flow through functions.
|
Research Project |
| Project #19 |
Draw UML Class Diagram from source code
The Idea:
Draw UML Class Diagram from source code using type analysis.
This entails parsing the code with something very close to the CodeAnalyzer. Evaluate
class relationships and build a relationship graph.
You will need to place graph vertices (classes) using something like the Graph Visualization
project. We probably would choose not to use all the UML symbols in the first version, perhaps
drawing directed arcs (with arrowheads), labeled by relationship type.
You probably need an intermediate file store, XML or JSON, written by the code analyzer and
read by a graph display program, rather like the Program Animation project.
|
Portfolio Project |
| Project #20 |
Generate source code from UML Class Diagram
The Idea:
Generate source code shell from UML Class Diagram persisted to XML or JSON
Provide a graphical editor for the user to draw a relationship graph and annotate its arcs
with relationship types. Persist that to an XML or JSON store, using the same formats as used
in the UML Drawing project.
Now, read the persisted store and generate source code shells, based on text patterns you build
as part of this project. The generated code will have classes with empty methods, much as
a Visual Studio wizard generates.
|
Portfolio Project |
| Project #21 |
Build an Object Model for HTML5 canvas drawings
The Idea:
Build an object model in JavaScript for HTML5 canvas drawings, e.g., like Silverlight
In this context an object is a representation of a rendered view, properties, and behaviors.
Examples are things like shapes and widgets, e.g., Rectangle, EditBox, ...
This is a large effort, and this project should probably be thought of as a proof of concept
for something that might, eventually, be very useful.
|
Research and Portfolio Project |
| Project #22 |
Build Asp.Net Core Mvc web site
The Idea:
Build a fully functional Mvc CRUD website with associated webservice.
You should build a full featured site for a fairly simple application, so you get practice
with the Core pipeline, Authentication and Roles, Entity-Framework data operations, and use of
Blazor components.
You might make the application a personal website, presenting your interests and strengths,
a resume, sample projects, and contact information.
Add to that the ability to manage recruiter information, e.g., requests and your replys,
interview appointments, follow-up messages, etc.
|
Portfolio project |
| Project #23 |
Stories Web Site - structured to present stories about people, institutions, and projects
The Idea:
This site represents stories of people, institutions, research projects, ..., as
timelines containing story blocks. Each block probably contains an image or diagram,
text, and perhaps links to resources.
The time line is simply an ordered sequence of story blocks that can be manually indexed
or run continuously with each block being viewed a specified time. You might want to
allow the user to change the sequencing rate, but have each block have a relative time
duration, compared to its siblings. So changing the view rate simply multiplies each story
block's relative time by a base time interval, e.g., 0.8*2sec, 1.3*2sec, 1.0*2sec, ...
This site structure would be interesting to present personal stories for you and your friends.
So the site should be able to store multiple stories, allowing users to select which they want to
view.
The site would also be a useful way to present projects, e.g., story blocks for:
- Initial concept
- Requirements
- Design
- Implementation, showing UML diagrams and code snaps
- Testing
- Release
Since projects don't usually evolve linearly, we should be able to insert new blocks.
Perhaps to put a new design block after our current implementation block when we need to change
part of the design, followed by another implementation block that picks up with the consequences
of the design revision.
You might want to allow a sub-sequence of blocks, e.g., Design start, system design, storage design,
signal processor design, ...
There are a lot of opportunities here to try out different technologies, e.g., the MEAN or MERN stacks,
or Asp.Net Core Mvc. This could even be a completely static site design, so it could be hosted on github,
for example.
|
Portfolio Project |
| Project #24 |
Explore some of the popular or new JavaScript Frameworks
The Idea:
Build a speaking acquaintence with some of the newer JavaScript frameworks to decide
what you want to use later, or to build your background knowledge for interviews.
Explore Javascript Frameworka like Node.js, Express.js, Angular.js, Vue.js, React.js, and the new
Webcomponents developed by Google and standardized by W3C.
Build components for image sizers, sliders, menus, and even a revision of <details> to modify
its behavior in subtle ways. Use the components in some simple applications hosted in Express to
get a good understanding of the pros and cons of each technology.
|
Expand knowledge base |
| Project #25 |
Build personal website using MEAN Stack
The Idea:
Build personal website using MEAN Stack - MongoDb, Express.js, Angular.js, Node.js
The MEAN stack is a successor to the LAMP stack - Linux, Apache, MySql, PHP. It is a relatively
simple, well know and understood environment that provides a relatively light-weight web facility.
|
Portfolio Project |
| Project #26 |
Explore web-related open source projects
The Idea:
Get acquainted with a lot of the new JavaScript frameworks by skimming their documentation
and building some "Hello World" applications.
Explore web-related open source projects
like D3 - Data Visualization, node.js - http dispatching with JavaScript, Grunt - JavaScript utilities,
jQuery - cross browser JavaScript library, JSHint - Javascript static analyzer
|
Explore new stuff |
| Project #27 |
Create web apps using HTML and CSS with Mavo
The Idea:
Have fun exploring some new stuff
The Mavo web site makes some big claims. I have no idea if reality lives up to the promotion, but it
would be interesting to find out, and would not require a lot of work.
|
Explore new stuff
|
| Project #28 |
Integrate node.js with a C++ application
The Idea:
Node.js, when combined with a couple of its available modules, becomes a powerful HTTP message
dispatching system. This project will attempt to build high-performance distributed systems
by merging the best of Node.js with C++.
Integrate node.js with a C++ application. Here's some help.
Then implement MicroServices or a Test Harness using a process-pool, or a pluggable repository.
|
Portfolio project,
try new stuff
|
| Project #29 |
Try out the Silicon C++ Web Framework
The Idea:
It would be fun to dabble with Silicon C++ to see what it can do.
Try out the Silicon C++ Web Framework for building Web APIs in C++
|
Portfolio project, try new stuff
|
| Project #30 |
Explore the Rust Programming language
The Idea:
You will learn a lot by rebuilding one of your interesting projects in Rust.
Rust is a new language, developed by Mozilla, that generates native code, avoiding garbage collection,
and providing some of the same kinds of performance as C and C++.
Mozilla claims they are building major parts of their firefox browser in Rust.
|
Broaden expertise |
| Project #31 |
Learn a functional programming language
The Idea:
Learn a functional programming language like Haskell, Rust, Erlang, or Scala
to broaden your knowledge base and strenghten your tool set.
Functional programming uses very different programming constructs compared to
imperative languages. It is useful, even if you expect to spend almost all your
programming time with imperative languages, to learn the ideas that functional
languages bring to the party.
Functional Programming provides very different syntax and semantics compared to the imperative
languages like C++, C#, and Java. The Functional programming community has developed a number of
interesting ideas, mostly centered around type theory and the ability to provide tight specifications
of a program's semantics.
Functional programming has its roots in ML and now uses Haskell, Erlang, Scala, and Rust, and others.
|
Expand knowledge base |
| Project #32 |
Start Research on Bayesian Networks
The Idea:
Bayesian Networks are a very broad, interesting, and challenging area of study. You won't
be able to do anything interesting quickly, but you might find an area of continuing interest
for your spare time.
Wikipedia - Bayesian Networks has an interesting
and well crafted summary of the area. One academic,
Daphne Koller,
Stanford, has done some very practical work with Bayesian networks that I found interesting. This may turn into
a retirement hobby for me, once more immediate interests are satisfied.
|
Research Project |
| Other Projects |
CSE687-OOD S2019
CSE687-OOD F2018
|
Improve development skills |
