Hi! My name is Ben Marks, and I'm a student at Swarthmore College - a small liberal arts school about 20 minutes from Philadelphia. At the moment, I'm on track to complete a major in Computer Science (CS) and a minor in Statistics. My main interests are in computer systems, distributed systems, and networks.

On campus, I'm part of the Swarthmore College Computer Society and a tutor for the CS department. Outside of CS, I enjoy playing trumpet in the Wind Ensemble, working as a Student Academic Mentor, and taking part in Swarthmore's Learning For Life program. In my free time, you can find me cooking, biking, or working on something CS.

Feel free to check out some of my work on the "Projects" and "Jobs" pages.

Studying computer science means that I get to do some cool projects at school and in my free time.

As part of the Operating Systems course at Swarthmore, I worked with a partner to modify and add features to the Linux 2.6 Kernel.

Together, we implemented an Event synchronization primitive. This allows multiple processes to open and wait on a single ``event.'' Subsequently, another process can open and signal the event, notifying all processes that were previously waiting that the event had occurred. This functionality is similar to the Python threading Event synchronization primitive. This synchronization primitive could be useful in many multiprogramming environments and has a slightly higher level of abstraction than semaphores or condition variables.

Another Linux addition was the creation of a Loadable Kernel Module implementing a mailbox device similar to a Unix named pipe. Processes can either read from or write to a mailbox, blocking appropriately if the mailbox is empty or full. Data in the mailbox persist past the life of a single reader or writer. Such a communication mechanism would be useful for exchanging data between two processes when a hierarchical relationship may not exist or when processes are specifically readers or writers.

Source: SVN (Login Required)

Implementing BitTorrent seemed like a fun project to work on over Winter Break that would strengthen my C skills with non-blocking I/O. My first experience with select proved to be a wonderful teaching moment for the importance of top-down design; I wanted to try using select again, this time going about the process of designing a complicated program the ``right'' way.

BitTorrent is a complex protocol, and I wanted to make sure that I implemented abstractions to handle some of the lower level components so that I could focus on the application layer details rather than debugging segmentation faults. Implementing a buffer manager and bitfield turned out to be helpful abstractions that greatly simplified by code.

I'm proud that I produced a working implementation that readily downloads and uploads data for single-file torrents (like Ubuntu ISOs) from real world peers discovered through communication with a tracker server. Feel free to check out and use the code on GitHub, linked below!

Source: GitHub

In Computer Networks, I had the chance to implement a stripped down version of TCP. My implementation provided reliable transit, flow control, and congestion control over a lossy network, along with smooth connection setup and teardown. In order to maximize transfer speeds, my implementation used the exponentially weighted moving average to estimate the round-trip time of a packet.

This assignment was fascinating. I enjoyed ``pulling back the curtain'' on TCP and seeing how some of the features of reliable transit used constantly could be implemented. Simple concepts, like acknowledgements, sequence numbers, and timeouts combined to create a powerful, useful service of reliability.

Source: SVN (Login Required)

Implementing a dynamic memory allocator is a standard assignment at many schools, although it's not assigned in the Computer Systems course at Swarthmore. As a Ninja for the course, I decided it might be a fun opportunity to hone my C skills.

My implementation uses explicit segregated free lists in powers of two. I found that choosing the first block within a list that would fit provided an acceptable balance between space utilization and throughput. Further, I chose to allocate space from the end of a free block, which greatly improved performance with repeated calls to realloc. I use coalescing when freeing blocks to reduce external fragmentation.

While I wasn't submitting this assignment for a grade, I'm pleased that my implementation scores 56/60 on utilization and 40/40 on throughput on the CMU driver program.

Source: SVN (Login Required)

When writing C code, I find myself using certain functions, such as a wrapper for malloc, frequently. I decided to start integrating commonly used functions into a library that I could then statically link at compile time.

At the moment, my library includes functions for reading in user input, manipulating strings, timing function calls, generating random numbers, and calling malloc. I also have a Makefile that compiles all the library files into a single library. The Makefile uses wildcards and filters to incorporate new library modules into the library without modifying the Makefile.

Feel free to use this library, and let me know if you find anything that doesn't work well.

Source: SVN

Introduction to Linguistics exposed me to sociolinguistics - the study of the interaction between language and society - for the first time. Our final project was to use a corpus containing the experiences of ~30 bilinguals to comment on and analyze the bilingual experience. I proposed an alternative project based on computer programming: writing a framework to compare similarity between two stories in the bilingual corpus.

Such a framework could be useful in determining which experiences are common to bilinguals or which components of the bilingual experience may be correlated. Under the supervision of Brook Lillehaugen, I developed criteria for characterizing a bilingual experience and implemented a program to interface with and analyze a set of characterized stories. Given a characterized corpus, my program allows a user to filter stories by certain criteria, see the commonalities between two stories, or determine the similarity of one story to all other stories in the corpus.

I'm happy that this program may be distributed in future semesters to linguistics students in this course. The framework should prove helpful by allowing the students to find and take advantage of patterns within the data of collected stories.

In the future, I would like to try to improve this program to include more sophisticated aspects of computer programming. As a Junior, I plan to take Databases and Natural Language Processing, both of which could lead to enhancements in the similarity matching or performance of this framework.

The summer after high school, I worked at Camp Ramah Darom as the technology coordinator. When I had time outside of this, I worked in the mail room. On any given day, we received up to 200 packages, which all needed to be sorted and logged. The process took 5 people 1-2 hours. The following summer, with a little bit of CS experience, I decided to see if I could write a program that would make the process a bit less painful. I wrote a macro-driven form in Excel that took in information about each package and logged it in a daily database. As an added bonus, the spreadsheet stored prior package senders, so any particular address only needed to be typed in once per summer. Once all packages had been logged, the daily database was sorted by bunk and printed.

The Excel program saved a lot of time. In particular, it omitted one time-intensive step from the package process: sorting packages by bunk. When logging packages by hand, it made sense to sort packages first and then log each bunk as a group. However, since Excel could sort the packages at the end of the process, the initial sorting process was no longer needed. The end result: a streamlined and efficient package logging solution that was easier and faster.

In July 2011, I participated Summer Ventures, a North Carolina - funded academic program for students interested in science and math. While in the program, I studied Visualization and Image Processing under Dr. Rahman Tashakkori. My final project: a Matlab program to recognize the characteristics of SET cards based on an input image. I also added functionality to the program that detected whether three input card images formed a SET. I received an honorable mention for my work.

Summer Ventures was a great learning experience, as I enhanced my abilities with technical writing, learned how to use Matlab, and created a functional program incorporating concepts from the course.

Source: SVN
Other Files: Paper, Presentation

I've been fortunate to have opportunities to apply what I know, learn new material, and collaborate with others.

Student Academic Mentor

I am excited that this coming year I will be a Student Academic Mentor (SAM) at Swarthmore College. As a SAM, I'll be a resource for residents in my dorm, helping them to be successful academically at Swarthmore.

The SAM position begins with Freshman orientation, helping over 300 new students register for classes and adjust to college academics. It continues throughout the year, where I'll be accessible to students within my dorm and around campus for any student who needs help or wants guidance. SAMs work with students from all years - from seniors who want to find resources for careers to sophomores declaring their major. As a SAM, I'll work closely with students, professors, and the Dean's office to help facilitate success.

I'm excited to work with my peers and help them make the most of their college academic experiences.

Research Intern

In January 2014, I had the opportunity to work with Tom Kramer at the National Institute for Standards and Technology (NIST) in a week long shadow program. While there, I contributed to Mr. Kramer's current research paper: ''Software Tools for XML to OWL Translation.'' The paper summarized a set of tools developed at NIST for effectively converting XML instances and XSD schemas to OWL (Web Ontology Language) classes. My own contributions included evaluating the asymptotic complexity of the implemented tools and contrasting them with existing conversion utilities.

The process to publish this paper is ongoing.

Student Mentor / Ninja

My sophomore year, I worked for the Computer Science Department as a Ninja (Student Mentor / TA) for the Introductory Computer Systems course. In this role, I mentored ~35 students each semester through weekly help sessions and assistance in lab sections. The position also involved weekly pedagogical meetings focused on effective ways to help enrolled students develop problem solving and programming skills.

Being a Ninja was incredibly gratifying, as I was able to see other students improve their own skills over the course of the semester. I enjoyed sharing my enthusiasm for computer systems with other students while helping them progress in their CS careers.

System Administrator

Since freshman fall, I have been a system administrator for the Swarthmore College Computer Society (SCCS).

SCCS is a student run organization that provides computing resources, such as mailing lists and websites, to student groups on campus. We also maintain an online student photo directory and a computer lounge for student use.

As a sysadmin, I'm responsible for the backend of SCCS - a role which has taught me many practical skills about server administration and troubleshooting. I also serve as the treasurer for SCCS, overseeing our budget of over $2,000.

Working for SCCS is challenging and satisfying. I proud that some of the work I do is used by students daily, and I'm challenged to maintain a level of service expected by our users: peers and faculty.