tags:

views:

answers:

As per title, I would love to hear from anyone willing to share their experience working on their CS FYP.

Was it academic/proof-of concept or
did it have real world applications?

Did it become bigger or was it
shelved after you graduated?

How did working on the project
contribute to your
skills/experience/future career?

Which would you have preferred: An excellent implementation of a normal idea or a normal implementation of an excellent idea?

A:

My team was working on a corporate social networking type thing. We did plan on continuing with it after school, but half the team didn't want to keep going after we graduated, so it was shelved. However, a big chunk (probably about a third) of the code in it has been repurposed.

The biggest contribution to my life from that project was experience as a project manager and systems analyst (I've always been a programmer, but never had to manage other programmers, and did little real - outside of class - analysis). It's given me a lot of insight into my job. My side projects have also benefited tremendously.

Did an analysis of an algorithm for automating gene location in a large DNA strand. My supervisor had developed the algorithm, but he was a CS prof, and I had minored in Biology, so I could actually look at his algorithms and see if they made biological sense.

Mostly it was fairly theoretical, mixing between pattern matching and tests for randomness, but there was a practical component of being able to identify true results, as well as false positives and negatives.

I learned to be politically aware from this project (the prof didn't like my results, as they indicated that his algorithms were not as good as he thought). I believe it was shelved after I left, for the same reason. So far I have not made use of it, although I wouldn't mind working in that field again (bio-tech, bioinformatics, etc).

Resource Discovery with the help of WebServices for Distributed Computing

Or at least that's how I would translate it in english. We had to create an extension to ParoC++ (a language based on C++ that help you write and run large distributed programs for High Performance Computing). We had to replace the resource discovery part with an implementation based on Java, SOAP and Globus.

This was mainly academic. The based project (ParoC++) is used in error detection of textile printing and avalanche simulations. But our implementation has never been used in any real project (as far as I know).

It was a lot of fun. It helped me understand quite a few things about C++, Parallel programing and multi-threading. The title sounds dificult enough that when I mention it in an interview people might think that I am actually smart ;-)

Mine CS final project was a question/answer memorizing web app in J2EE. I figured I'd need it in the future for my career. It was a bit like Quizlet. Only the kid that wrote Quizlet had better technology to work with than I did (I had pure servlets). J2EE was really new when I built it, and it never really got it completely finished, but I got a good grade on it. I also used a Java Applet that would store the values of the question/answer being edited in a hidden field on the page to be submitted to the server. I never did get the sharing quizes bit done, the semester ended before that.

me and my pals came up with the idea of doing a music player. we had all used various ones, such as iTunes and media monkey, with varying levels of success. We liked some features of all of them, so decided to create our own with all the best features.
The most important thing we found was to be ambitious. If you think you can't do something, remember that you have about 6 months to do it, you don't have to do it tomorrow. The main features we implemented included:

3D interface
We decided to make the UI completely 3D, with a cube at the centre, that would rotate to show the album artwork of the new song. This is similar to the iPod touch visual display

Algorithm framework
We built a framework to plug-in algorithms as we created them, that would analyse each song we added to the Library. This was an important feature as it allowed other features to use the information gained from these algorithms. Examples of these included BPM detection

DJ-mode
This was the big fish of our project. Given a set of criteria set out by the user, such as the artists they liked/disliked, or the genre or BPM range of songs that they prefered, the applicatuon would scan through the library to create a playlist of songs to match the criteria. This is similar to the new Genius functionality in iTunes, but i'd like to point out, we completed this in April '08. If only we patented it ;)

Thats just a small snippet of what we did. 6 months of blood, sweat and tears later, we were contenders for project of the year.

I worked with a team on a project for viewing stock trades and purchasing them through an account with a company. This was a Blackberry application and it was very difficult to program for because of the unfamiliarity with Blackberry and no working hardware device. As far as I know the project was intended for use within the company but I can't be sure what actually happened to it. The project didn't really contribute a lot to my success or demise as a software developer. It did teach me how to waste 9 months documenting things unnecessarily.

Once the project was finished, RIM decided to come out with a Blackberry plugin for Eclipse. That could have saved us a lot of work.

A client-library for Whois++, a directory technology from when LDAP didn't yet seem like the final winner.

Got me my first job, where I was lead developer (release manager, QA, etc) for the reference Whois++ server and where I edited the RFCs defining the protocol. Dead-end technology in the end, but it was a great gig for a kid just out of school, trying to decide which way to go.

Also, I expected to make a career of System Administration, and I wanted to have a solid research, IETF, and software development job on my resume before wading into the sysadmin ghetto. Why? Because I'd noticed at a summer job that there are two kinds of sysadmins, the ones who just muddle through for 30 years, and the ones who are engineers first, and sysadmins second. I wanted to be the engineer kind, not the muddling-through kind.

Multi-player paint. No, seriously. I wrote an application which shared a canvas over the Internet, it was proof of concept but I got it working and demonstrated it at a computing event. I think I've still got it around here somewhere.

As for how it helped me in my career, well it gave me a real insight into fast-paced development. I've learnt far more from my job, but it helped me get my degree which essentially helped me to get my job in the first place.

I wrote (in 1997) a Bot in Perl that looked for broken hyperlinks on webserver. I had a flag that would turn turn off the "stay on this webserver" which would cause it end up in the weirdest places on the internet. I wrote it on Slackware 5. We used DEC Alpha's at school.

I extended an existing OCR algorithm to work in adverse robotics environments. That mostly involved:

tweaking the algorithm to deal with bad lighting, skewness, etc.

matching characters into words and lines

using dictionary to improve recognition scores

swearing at the wretched little robot when it ran out of batteries/froze/got stuck in a corner...

It was no rocket science, but it was a good foundation for learning how to work in a research lab, including all the politics involved, to work independently on a long term project, and to write reasonably scientific-sounding reports. Plus, it looked impressive on my graduate scholarship applications. A pretty good learning experience all in all.

It ended up part of a published paper, and got used for a couple of years after that at least.

In 1982, I wrote a FORTH interpreter in C. Teaching myself the language straight from K&R as I went.

No help from any academic staff since they didn't know the language. They were against me using C at all and wanted me to do it in Pascal, but I reckoned I needed pointers to functions to do the project justice.

A Java framework for distributed algorithms, a bit like [email protected] Plus two algorithms to test it. One of which tried to calculate the shortest route between all the cities in Belgium running on the school pcs.

I wrote a PDA application which connected to a central server to access data for remote engineers around our computer science block (within wifi range) to stop them having to go back to their help desk to get new / updated help tickets. It had the details and could access and notes (and add new ones). It was pretty basic, but got to learn c#, web services, few other bits and got to play with a PDA for a year. It was in VS2003 and .net 1.1 and I learnt a lot ... and it helped me pass my degree!

Looking back I'd have done it a lot differently now but that's looking through the eyes of experience. Also if I was doing it now I'd use WCF and an ORM etc. etc.

My project was to see if humans could better visual complex state machines using 3D space (think minority Report style but without the crazy gloves and massive telly's). It would interpret 2D statemachines that you created or were already available and give them depth and allow the user to move around, zoom in/out, run the state machine etc.

The basic answer from nearly 9 months work was that most of the time 3D actually made it more complicated to comprehend. Maybe in the future when humans get more and more used to seeing 3D shapes on a 2D screen and methods of interaction are improved it will get better.

As far as I know it was shelved after I left. I certainly haven't seen any royalty cheques in the mail recently ;o)

My senior CS project was a working donor database application (this was 1987) for the school's Association of Graduates - my understanding was that it was going to be the starting point for the system they would eventually use. I even implemented a text-mode windowing system for the entry and query forms, and you could start typing a donor's last name, and it would interactively display all matching records instantaneously. It would also pop up an easter egg when you typed the professor's name in...
But that was easy compared to my EE project - we built a working RAM card for an STD-Bus computer. That project ate my life...

Edit: I forgot my graphics track senior project - I built a 3D, interactive Rubik's cube, which was exhibited at SIGGRAPH in a display for computer science student's work. And this was without a nice standard graphics library like IrisGL/OpenGL. But it was an awesome project.

by Swing UI I could extract the measures (Chidamber & Kemerer, Function Point, etc); the user could create him personal metric (as SQL code) and could see the statistical values of every predefined metric;

I had a capstone project as our final final class, but before that I had a software engineering class which was pretty much the same as a capstone but with more engineering methodologies in it. I've only finished my associates degree but here's my petty accomplishments:
For my software engineering project, we created a top-down shooter game using C++ and DarkBasic.
For my capstone, we made a Microsoft Money type system but it saved to a database instead of the local computer so you can login from anywhere to modify your stuff.

Having a radical idea is one thing, but seeing it through to (commercial?) success is often another. Maybe the trick was to realise the true potential of your ideas; after all the PC is still very young technology. +1 for your answer

2005 I developed a software for controlling, programming and monitoring industrial robot working cells and then used it on a cell which assembles robot controllers. So the software today controls robots that build robots... :)

We started a company last year and we're now doing a new version of the application with more commercial focus. We've taken some steps towards a patent for some of the ideas in the first version but it is unfortunately too expensive to take it all the way.

I worked on a project called Kifano, which used a library for computing the differences between two pieces of music, to help generate music recommendations based on a set of known "liked" songs. The backend music analysis was done in Java, and the user application was a Ruby on Rails application.

In answer to your questions:

I suppose it was both - proof-of-concept in that the application demonstrated that "sounds-like" metrics generate reasonable recommendations; and real-world, in that actual people used the application.

It was shelved, wish I had time to work on it more.

It taught me an awful lot about working on large codebases, particularly the value of version control (i.e. I wish I'd used version control!).

I worked on the "detection" aspect of a vehicle license plate detection system. The challenge was to get a dumb computer to detect where the location of a vehicle's license plate on the image is. Given very tight constraint, the problem is surprisingly easy. However, I wanted it to be robust for arbitrary rotation of the license plate. I also wanted it to worked regardless of the lighting condition. Finally, I wanted it to make no assumption on the minimum and maximum size of the license plate itself on the image.
To a certain degree, I have achieved these goals but still there are lots more opportunity for improvement.

The method that I used is based on graph cut segmentation and SVM. In the end, a paper was published to ISNN 2008.

I developed a software in C++ to transfer data from one computer to another using FM frequency. I managed to send data from one to another but not vice-versa. Next year students picked up the project to develop two way communication. I don't know if they were successful or not.

This was in 1998 and now we have infra red, bluetooth etc.

I am in IT field developing applications for travel industry so not exactly matching to what I did in the project but yeah it helps providing experience of developing a working software.

Picking geometry that was perceptually relevant to the user (with a bit of machine learning on simulated user runs through the data set), guessing where they were going to go next and sending the right geometry as a prefetch, doing hidden surface removal on the server at run-time and via pre-processing.

Plus some novel (but flawed) compression algorithms based on genetic algorithms. It was a real grab-bag of techniques.

I made a somewhat more complex little man computer model (Based on my professor's design) called the Post Room Computer.

The program featured an assembler / compiler (which supported label and macro substitution) and two different computers models (One absolute addressed and one Register addressed).

The program 'compiled' the assembly language (No 3rd party parsing libraries were used) into decimal machine code which then could be executed on either of the emulated computers (were complete with memory, register, and ALU components).

All of this ran on top of a pretty GUI (although it could be run from the command line also) The final project was awarded 72% (A 1:1).

Basically given a scanned document image and the OCRed text, locate and highlight certain words in the image. The challenge was that the images were pretty poor quality. The dataset I was using was a collection of scanned 150+ year old newspapers. Very dense print, torn pages, distorted pages and some were rotated up to 5 degrees on the scanner.

I got it working for most situations, but I dont think it ever got integrated into the Greenstone codebase.

My undergrad project was a system to translate compiled x86 binaries into Java VM bytecodes. It was very rudimentary (it actually took in assembler mnemonics and output Java source code, and it only worked for Hello World and some simple arithmetic instructions, but it had a nice pluggable architecture and could have been extended quite easily.

My MSc project was about the evolution of camouflage patterns. I used a bio-inspired computer vision network build with Numenta NuPic to evaluate patterns generated with a particular kind of weighted cellular automaton. The vision system was looking for "prey" patterns embedded in a background pattern. It worked pretty well, and with a high-resolution image sensor and some co-adaptation between the vision system and the patterns, it could evolve pattern weight sets which more-or-less perfectly blended into the background.

it was in 2002, i implemented the concept Steganography in c language. Its was the time when 9/11 attach and reports says the people involved might used this concept. having this an interest, we started learning the concept of steganograpy.
The implementation is, embed a text file in to a BMP image and transfer the image via any medium. the decode algorithm extract the same file out from the bit map image raw bits. the same concept we tried in the WAV files and got success after the project.
Now i am an application developer using c/c++ language. involved in writing a framework code which involved various report format (xml, pdf, csv)generation from application text report.

We wrote an online image management system for thousands of high resolution blood slides, for biology students and researchers at my uni. Basically, it had to restrict and track downloads, allow categorisation by different blood cell types and deformities etc, and provide some basic login and reporting features..

It was in PHP, and it was before I learnt about the joys of PHP frameworks (it could have made our lives so much easier). We worked in a team of 5. It was a good opportunity to self teach ourselves how to do things like image processing, captchas, tagging systems, subversioning etcetera.

It was a good lesson in dealing with clients as well, the client kept changing scope and feature requirements every couple of weeks. In the last week she even changed her mind about it running in PHP and MySQL and wanted us to change it to ASP and Oracle, because she'd heard that those were better.

Last time I checked it was still in use at my old uni. Looking back, my code is quite horrific! But at least it proves that I have learnt something after uni :)

As per the curriculum in my school, we had to carry out 2 final year projects, and 3 including the pre-final year internship. Here are they:

I worked on Default Reasoning using Fuzzy logic during my summer internship and had succesfully done a literature survey of Commonsense Reasoning. I developed some worked out examples to demonstrate my work in Default Reasoning using Fuzzy Logic. The whole exercise was intellectually simulating

For my first final year project, I studied parallel programming with MPI and PVM. Since, I did not have an idea about parallel computing till then, the project taught me a lot of them. I also brainstormed a MPI plugin for GIMP to enable Parallel Image Processing. Sad, that I never managed the time to implement it

This was rather stupid, though learning experience. I developed a management tool with the all the stupid GUI for Software RAID on Linux. It was a pretty handy tool which could be used to teach software RAID

The best part and the reason for which I chose them (My profs, didn't) was that each project taught me something which I didn't know previously and that IMO should be the ONLY goal for a project.

I did the only research-oriented project in my graduating class: Separating easy and hard logic programming problems. This is related to satisfiability (3- and k-SAT) and stable models.

The results are for use in solving logic (NP Complete), revealing what conditions in logic problems caused a noticeable increase in time-to-solve. I created a program to randomly generate hundreds of programs for every ratio of rules to variables and clauses. The results can then be graphed in various directions to show there is indeed an mixture that makes programs significantly more difficult to solve.

I did a proof of concept on Image Recognition. This was back in 1994 so it was the VB3.0 era. I used C however and the project was to track dolphins in the Gulf of Mexico. Apparently you can recognize dolphins by the fin on their backs. Each dolphin's fin has unique markings, shape, size and the marine biologists at our college wanted to track the dolphins from images.

I ended up with a team where we developed a scheduling system to be used in state run jails throughout the northern part of our state. We partnered with a local firm that got the bid for the project, and we did most of the hard work (ie developing the algorithm from an academic paper). We gave a large presentation with the chancellor and many of the university staff (we filled our large lecture hall). The firm was very impressed with our algorithm, but did end up re-doing our presentation layer.

We did get a letter of recommendation from the chancellor and the CEO's firm.

Here is how it worked at my school: companies would present projects to the university. Students would choose a project and work in teams of 5-6 people. Someone from the company would act as the team mentor and make sure you were on the right track.

It sounds like a good idea to run a project like this, structuring the project so that students get experience with a large development effort and deliver something with real world value.

We were given the task of optimising a universal medical record application that was woefully slow. We were given a massive VB app and some DLLs that interpreted the format of the medical records. On inspection we discovered that the DLLs were the main bottleneck in the performance. Unfortunetely the company in question did not want to give us the source code to the libraries. The mentor was a business improvement type who didnt really understand the problem. It was too late by this time to start a new project.

So in the end, all that we delivered was a document explaining where the bottlenecks were and why we couldnt fix them. It was supported by some charts generated by a profiling app.

I remember being quite despondent at the time about the outcomes of the project and how little we'd managed to achieve from a technical point of view. We ended up with a fairly good mark though because our document was very thorough. That was about five years ago.

Now I realise how much that project taught me about business communication and presenting technical arguments to non technical people. Being able to explain to management in a clear and quantifiable manner why some idea, approach or requirement is not a good idea has saved my sanity many times over.

Effectively you would create a fault tree in the software for a given system that you were analysing and the system would allow you to drill down and map the faults, failures etc. of the system to predict its probability of failure.

You could then create requirements based on your analysis to try and prevent these from occuring. The system would print out a great report with a representation of the tree and the final derived requirements for establishing the software. Working with a defence contractor and the government looks really good on your resume as a graduate.

My final project was actually a series of projects that I was working on in the office that (thankfully) I was allowed to submit as my final project. The projects focused around the internal tooling of a team who needed to improve document management, password management (for servers, databases etc) as well as catalogue all of the tools that they were supporting (over 200 at the time).

In a lot of ways the projects themselves were simple. It was a case of making everything work together. For example, the application database tied in to the infrastructure monitoring tool to help keep tabs on server uptime. It became a simple case of pulling a report to find all of the affected applications (and their dev leads) in the case of a server outage.

The tooling was simple, but the tools served their purpose and are still in operation today.

I was on a 2 man team (well 3, but the third did sweet f-all) and we made a multiplayer overhead perspective shooter. It was tonnes of fun.

I worked on it a bit after I left school, adding an existing OS physics engine to it, but once I started working full-time, I've always had so many other things to study and work on that would advance my current career.

I learned a lot of little things, working on the project but I took the most from writing the network code and game state machine as they were my biggest introductions to network programming and design patterns that went beyond labs with instructions.

The part about the project that really made it stick out as both memorable and a good learning experience was that the project was a 'choose your own adventure' type thing. Our prof told us to make whatever we want, he just had to vet it for difficulty first. Some people hacked up small firewalls, some wrote IMs (I had already written one for another course), some wrote webapps. So there was the option to make "an excellent implementation of a normal idea or a normal implementation of an excellent idea"

I created an app in Java to discover solutions to the Prisoner's Dilemma using Genetic Algorithms. The bit string population was spread over an area with various selection techniques based on location and other things as well as the fitness.

It included a front end that displayed a grid for the population area and then I made the display of each bit string a small circle of a colour (determined by its bits) and added legs and eyes, I called these (and the app) "Danimals". A picture of a few Danimals is available here.

I received a first for the project but didn't continue it after university.

I worked part time at my school, and knew many of the admissions officers. While my team and I were trying to figure out what to do for our project, I showed a little program that I created to the head admissions officer and she loved it.

I hated trying to schedule my classes. I would color boxes onto transparencies and lay them on each other to find schedules. I whipped up a little program with Java and Swing that would read in the times courses were offered and would show me every permutation of the schedule, giving me at least X hours. This meant that instead of spending a couple of hours trying to figure out a schedule (and change it as classes filled up), I could type in a couple dozen lines from the course catalog into a simple CSV like format and have my program display possible schedules for me.

It looked quite nice, which was probably a help. Basically copying the way iCal shows things helped there.

So for our project, my team and I took my little program and added a database back end and web front end that would allow the administrators to easily add/update classes so that students could always get the latest update of courses without having to filter them by hand with open/closed courses. We also added additional features such as supporting more schedules (half-semester classes instead of just full, etc.), printing (which was a big challenge), and more.

It was actually a pretty fun project. I'd love to know if they use it, but I haven't asked. The corporate office was apparently interested in it. I found my program very useful, I really hated trying to piece schedules together.

It had it's problems. The PHP front end to the database was rather ugly, but I knew that at the time. Having it connect directly to the database was a mistake. It couldn't do much thanks to right limits, but it should have asked through a web-service or something easier to secure/replace.

Still, I learned a ton, especially with the requirements that I never would have thought of based on real world scenarios that the school had to deal with. It had to be able to show more than 8 different courses on a schedule and handle over 50 hours a week, both of which one poor student took once.

I had no idea what I wanted to do for my FYP. My university provided lists of projects that they would like to see done, so I ended up creating an Old Irish font with Metafont. That was it really and I could have done more.

I would have preferred to do something more programming-like although I had to learn how to use Metafont myself as no-one in the university had ever used it! So I suppose that was useful.

Senior year project in 1973: designed a system programming langauge much like C (this was before C became popular!) and implemented it using assembly code for an assembler that I built, all for a 12-bit custom minicomputer. The language was cleaner than C: no direct gotos (you can code entirely without them if you can label blocks and jump ("leave") such labelled blocks).

This langauge became self-hosted, and then became the foundation for an OS and development tools (editors, numerical machine controls) for a 16-bit stretched version of that same custom minicomputer.

Built a database that pulled data for the top S&P500 companies every 15 minutes for 6 months then trained an artificial neural network to identify trend data and make predictions on future trades for single stocks as well as groups of similar stocks. This project along with two other pretty cool ones caught the attention of local employers and landed me the job I'm in right now writing writing distributed SCADA applications. I plan on picking the up the code base when I get some time to make the process modular, more automated and expand the size of the neural net by a factor of 3-4x in an effort to apply the technique to other data sets such as march madness basketball or much longer larger blocks of stock data.

A computer vision system that would take any arbitrary object and reconstruct it as a 3D model. It used a turntable (we had ours working with an old record player) and a web cam which would record a video of the object rotating and then feed the video to the software we wrote to build the model.