ACM Introductory meeting(+ presentation from Dr. Mount) 🥳
2023-11-07 18:30 - 19:30 (America/New_York)
RSVP Here
Update: Location will be IRB 4105

Get Ready to Ignite Your Passion for Computing!
Hello, Terrapin Tech Enthusiasts!
Are you ready to embark on a thrilling journey through the world of computing? We’re excited to announce the revival of the Association for Computing Machinery (ACM) at the University of Maryland, and we want you to be a part of it!
Our first meeting is this Tuesday from 6:30-7:30. We’ll talk about what the ACM is and our plans for the future. We’ll also have Dr. Mount presenting a computational geometry problem as well as how to get into undergraduate research at UMD. This is a great opportunity to learn from one of the department’s most esteemed professors!
Why Join ACM at UMD?
Expand Your Knowledge: ACM offers a platform to stay up-to-date with the latest trends and innovations in computer science. As a member, you’ll have access to cutting-edge research and resources that will enhance your academic and professional growth.
Network with Peers: Connect with like-minded students who share your passion for technology. ACM provides numerous opportunities to collaborate on exciting projects, learn from one another, and make lasting friendships.
Boost Your Career: Being a part of ACM can open doors to internships, job opportunities, and valuable industry connections. It’s the perfect platform to kickstart your tech career and gain the skills that top companies are looking for.
Hands-On Experience: Engage in hands-on coding sessions, hackathons, workshops, and tech talks. ACM at UMD will empower you with practical skills that will set you apart in the competitive tech world.
Innovate and Create: Bring your brilliant ideas to life with ACM’s support. Whether you’re interested in AI, cybersecurity, web development, or any other tech field, we’ll help you transform your dreams into reality.

Diverse Community: ACM welcomes all backgrounds, skill levels, and interests. We believe that the best solutions come from diverse perspectives. Join us, and together, we’ll create a vibrant tech community on campus.
Join us for our kickoff event on November 7th at 6:30-7:30, where we’ll introduce you to our vision and plans for ACM at UMD. Stay tuned for more details!
Stay connected with us on our discord and our official website. We’ll keep you informed about upcoming events, workshops, and the incredible opportunities that await you.
Don’t miss out on this chance to be a part of the ACM community at UMD. It’s your time to shine in the world of technology and computer science!
Discord: https://discord.gg/3Azt2FQPJt
Terplink https://terplink.umd.edu/organization/acm
Let’s redefine the future of technology together. Join us on this incredible journey, and let’s make ACM at UMD the epicenter of computer science excellence.
See you at the kickoff event, and remember, the future is code, and it’s bright!

ACM meeting - Tuesday December 5
2023-12-05 18:30 - 19:30 | Iribe Center University of Maryland, 8125 Paint Branch Dr, #1207, College Park, MD, 20742, United States
Hello Everyone, the next ACM meeting will be on Tuesday 6:30-7:30 at IRB (Iribe) 4105. We’ll be hosting Professor Justin Wyss-Gallifent for a lecture on quaternions! This is an amazing opportunity to explore the field of computational geometry further and connect with peers and faculty! Hope to see you all there.

ACM Kickoff Meeting
2024-02-13 19:00 - 20:00 | IRB 1207, 8125 Paint Branch Dr, College Park, MD 20742, College Park, 20742, United States
Join us for the inaugural meeting of the semester in collaboration with ACM DC as we kick off with a very relevant talk on navigating the current tech economic downturn. Our esteemed speaker, Yingquan is an industry professional with 8 years of computer science experience, a master’s degree in data science and an officer of ACM DC.He will delve into the turbulent landscape of the technology industry and the broader economy. With experience and expertise, Yingquan will draw parallels between the present situation and past economic downturns, such as the 2000 dotcom crash and the 2008/09 financial crisis. In his talk, Yingquan will equip attendees with a practical mindset and actionable tips essential for successfully navigating these challenging times. Whether you’re seeking internships, jobs, or aiming to launch a career in tech, this session promises invaluable insights and strategies for the road ahead. Don’t miss out on this opportunity to gain invaluable wisdom and guidance. Mark your calendars and join us for an engaging discussion this Tuesday (the 13th of February) in Iribe 1207 from 7-8pm!
RSVP Here: https://docs.google.com/forms/d/1XAzkQnYZVGDed4pspLXD8OiiWX9zEiAfz0jag6TW0Ss/edit#responses

ACM General Body Meeting - Intro to Quantum Computing Workshop
2024-02-20 19:00 - 20:00
Quantum computing leverages quantum mechanics to process information in ways that classical computers can’t, potentially solving complex problems much faster than ever before.In general computing, information is represented using bits, which can be either 0 or 1. However, in quantum computing, quantum bits or qubits are used. These qubits are unique, because they utilize the quantum principle of superposition to be in both the 0 and 1 position at once. In this meeting we’ll go over this unique phenomenon, learning about the unique advantages quantum computers have over classical ones and an introduction to developing quantum algorithms using IBM’s qiskit library, with the goal of understanding Deutsch’s algorithm, quantum teleportation and more.
Join us for this workshop at CSI 1122 from 7-8pm, official ACM merch like pens, decals and bags will be handed out for free while supplies last.

ACM Distinguished Speaker - Dr. Houbing Song: Real-Time Machine Learning for Quickest Detection
2024-02-26 18:00 - 19:00 | IRB 4105, 8125 Paint Branch Dr, College Park, MD 20742, College Park, MD, United States
Join us as we host ACM Distinguished Speaker Dr. Houbing Song, the Director of NSF Center for Aviation Big Data Analytics and the Director of the Security and Optimization for Networked Globe Laboratory at UMBC.
Dr. Song will be lecturing on Quickest Detection, which refers to real-time detection of abrupt changes in the behavior of an observed signal or time series as quickly as possible after they occur, is essential to enable safety, security, and dependability of cyber-physical systems (CPS). Real-Time Machine Learning (RTML) has the potential to achieve quickest detection. However, Machine learning lacks the necessary mathematical framework to provide guarantees on correctness. The integration of machine learning with quickest detection not only creates new research opportunities with major societal implications, but also poses new research challenges in safety, security, and dependability. Dr.Song will present a comprehensive survey of the existing literature, identifying trends, challenges and presenting his own novel findings in the area.
This is a great opportunity for anyone interested in machine learning or cybersecurity who wishes to learn about some of the cutting-edge research in the field. This talk will take place in Iribe room 4105 on the 26th of February.
RSVP: https://forms.gle/UMBSFrfFVzB1Bpjq6

ACM Speaker – Uttaran Bhattacharya: Research on Human Motion Synthesis
2024-03-12 19:00 - 20:00 | https://umd.zoom.us/j/2056242544?omn=91788681648
Join us on Tuesday for our next (virtual) meeting with Dr. Uttaran Bhattacharya: a Research Scientist at Adobe, alumnus of the University of Maryland, and winner of ACM’s MIG 2022 Best Paper Award.
During the session, Dr. Bhattacharya will delve into the intricacies of human motion recognition: its applications, challenges, and cutting-edge advancements. This presentation is an amazing opportunity to learn about how computers recognize humans whether you are a freshman college student or a seasoned researcher. Make sure to RSVP below so we can get an accurate count of attendees. We are looking forward to seeing everybody and learning more about how recurrent neural networks, GANs, normalising flows and other techniques can be used to analyze human motion!
March 12 | 7:00 PM – 8:00 PM | Zoom | RSVP

ACM Speaker – Secure and Trustworthy Machine Learning and Artificial Intelligence for Multi-Domain Applications
2024-03-26 19:00 - 20:00
Join us on Tuesday for our next meeting with Danda Rawat: a Full Professor in the Department of Electrical Engineering & Computer Science (EECS), Director of the Howard University Data Science and Cybersecurity Center.
During the session, Dr. Rawat will delve into the intricacies of security features in AI/ML models. This presentation is an amazing opportunity to learn about how to design ,evaluate and test ML algorithms and AI systems that produce reliable, robust, trustworthy, explainable, and fair/ unbiased outcomes. Make sure to RSVP below so we can get an accurate count of attendees. We are looking forward to seeing everybody and learning more about AI for cybersecurity and cybersecurity for AI for multi-domain operations and applications!
March 26 | IRB | 7:00 PM – 8:00 PM | Zoom | RSVP

ACM Speaker – Deep Learning for Software Engineering - Denys Poshyvanyk
2024-04-09 18:00 - 19:00
Join us on Tuesday for our next virtual meeting with Dr. Denys Poshyvanyk: a Chancellor Professor of Computer Science at William and Mary
During the session, Dr. Poshyvanyk will delve into how DL algorithms can enhance and automate several critical SE tasks involving natural language, code, and graphical user interfaces, including program prototyping and source code modifications. This presentation is an amazing opportunity to learn about how you can incorporate Deep learning into your software engineering workflow. Make sure to RSVP below so we can get an accurate count of attendees. We are looking forward to seeing everybody and learning more about DL in software engineering tools!
April 9 | Online | 6:00 PM – 7:00 PM | Zoom | RSVP

Alumni Callback - Syed Asad Musa
2024-04-16 19:00 - 20:00
Join us on Tuesday for our next meeting with Syed Asad Musa! A UMD Computer Science Alum, OMSE Academic Excellence Awardee and former treasurer of the ACM!
April 16 | IRB 2107 | 7:00 PM – 8:00 PM | Zoom | RSVP

Speaker - Dinesh Manocha: Research in AI and robotics
2024-04-23 19:00 - 20:00
Join us on Tuesday for our next meeting with Dr.Dinesh Manocha: Paul Chrisman Iribe Professor of Computer Science and Electrical and Computer Engineering and Distinguished University Professor
During the session, Dr. Manocha will talk about his research in AI and Robotics. This presentation is an amazing opportunity to learn about the intersection of these two fields in areas such as autonomous driving. Make sure to RSVP below so we can get an accurate count of attendees.
April 23 | IRB 1207 | 7:00 PM – 8:00 PM | Zoom | RSVP

ACM GBM - Multimodal LLMs - Sreyan Ghosh
2024-04-28 00:00
Join us on Tuesday for our next meeting with Sreyan Ghosh! A CS PhD candidate at UMD.
During the session, Sreyan Ghosh will talk about Multimodal LLMs and their applications. Make sure to RSVP below so we can get an accurate count of attendees.
April 23 | IRB 1207 | 7:00 PM – 8:00 PM | Zoom | RSVP

ACM GBM - Setting up your own LLM
2024-09-17 18:00 - 19:00
Join us on Tuesday for our next meeting as we walk you through setting up your own Large language model from the ground up!
Make sure to RSVP below so we can get an accurate count of attendees.
September 17 | IRB 4105 | 6:00 PM – 7:00 PM | Zoom | RSVP
Event Readme:
# Building a Basic chatGPT clone
In this workshop we will walk through the process of building a very basic website with the basic functionality of chatgpt.
We will build a backend with routing, a frontend for the backend to serve and hook up a basic conversational model to our backend
to generate the responses, which will be displayed on a simple web page.
## Table of Contents
1. [Prerequisites]
2. [Project Setup]
– [Setting up Python environment]
– [Installing Django]
– [Creating a Django Project]
– [Installing Transformers and Pytorch]
3. [Backend Development]
– [Creating Django Views]
– [Expanding our view with Transformers]
– [Improving our View]
4. [Final Notes]
5. [Further Improvements]
—
## Prerequisites
Before starting, ensure you have **Python 3** installed on your machine. You can verify this by running `python3 –version` in your terminal.
– You can install python by visiting the following link: [Python Installation](https://www.python.org/downloads/)
– For windows users, it is advised to use the command prompt instead of powershell
– To create files use `touch ` on macOS/linux, and `notepad ` on windows
For more detailed information on these topics, you can refer to the official documentation:
– [Python](https://docs.python.org/3/)
– [Django](https://www.djangoproject.com/)
– [Transformers](https://huggingface.co/transformers/)
—
## Project Setup
### Setting up Python environment
– Now that you have ensured that you have Python installed (`python3 –version`), create a directory called `ai_chatbot`(`mkdir ai_chatbot`)
– change directory into it with `cd ai_chatbot`.
– Next, create and activate a virtual environment:
– Virtual environments allow you to isolate your project’s dependencies, ensuring they don’t conflict with other projects on your machine.
– Run: `python3 -m venv .venv`. This will create a virtual environment in your current directory under `.venv/`.
– Activate the virtual environment:
– On macOS and Linux, use: `source .venv/bin/activate`
– On Windows, use: `.venvScriptsactivate` (This may not work in powershell due to security settings)
– If you are using a non posix compliant shell like fish, you may need to use `source .venv/bin/activate.fish` or something similar
You should now see the virtual environment activated in your terminal (usually the terminal prompt will start with `(.venv)`).
### Installing Django
– With the virtual environment activated, install **Django** using pip (Python’s package manager):
– Run: `pip install django`
– This will install Django into your virtual environment, making it available to your project.
### Creating a Django Project
– Now that Django is installed, you can create a new Django project. Run the following command:
– `django-admin startproject chatbot .`
– This will create the necessary Django project files in the current directory, including the `manage.py` file and the project directory (`chatbot`).
– You should see output like the following if you list the contents of your directory(`ls` for macOS/Linux, `dir` for windows):
“`
$ ls -al
drwxr-xr-x – user 15 Sep 16:34 .venv
drwxr-xr-x – user 15 Sep 16:43 chatbot
.rwxr-xr-x 663 user 15 Sep 16:43 manage.py
“`
– We can test if django installed successfully by going to the directory manage.py is in and running `python manage.py runserver`
– Then we navigate to `http://127.0.0.1:8000/` in our browser
– If it installed successfully, we should see something like `The install worked successfully! Congratulations!` as a webpage on the site
– press ctrl + c in the terminal to stop the execution of the webserver
### Installing Transformers and Pytorch
– Before proceeding to the AI part, we need to install Hugging Face’s **Transformers** library along with **Pytorch**, which we’ll use to load a pre-trained model.
– Run: `pip install transformers`
– Run: `pip install torch`
– At this point, you should have Django, Transformers, and Torch installed. In the next steps, we will integrate these into the Django app and set up the chatbot logic.
—
## Backend Development
### Creating a django app
– Next, we’ll start start a new app within the project that will handle the chatbot’s functionality:
– Run: `python manage.py startapp chat`
– This will create a new app directory called `chat` where the views, models, and templates for your chatbot will reside.
– Once the app is created, we’ll need to add it to our installed app which is in the django settings file
– Open `chatbot/settings.py`, find the `INSTALLED_APPS` list, and add `’chat’,` to the list. This ensures Django knows about your new app.
“`python
INSTALLED_APPS = [
“chat”, # Add this line
“django.contrib.admin”,
“django.contrib.auth”,
“django.contrib.contenttypes”,
“django.contrib.sessions”,
“django.contrib.messages”,
“django.contrib.staticfiles”,
]
“`
### Creating Django Views
– The chatbot’s logic will live inside a **Django view**. A view is simply a Python function or class that handles user input and sends a response to the frontend.
– In your `chat` app, open `views.py`. You will create a function that handles user queries and processes them using the AI model.
– The view will:
– Accept a message from the frontend via an HTTP request.
– Pass the message to the transformer model to generate a response.
– Return the AI-generated response to be rendered on the webpage.
– For now, we’ll create a simple view that simply returns “Hello World”
“`python
# chat/views.py
from django.shortcuts import render
from django.http import HttpResponse
def index(request):
return HttpResponse(“Hello, world!”)
“`
– To access it in a browser, we need to map it to a URL – and to do this, we need to define a URL configuration.
– URL configurations are defined inside each Django app, within that app’s urls.py.
– This file isn’t created by default, so we have to create it under chat/
– `cd chat`
– `touch urls.py`
“`python
# chat/urls.py
from django.urls import path
from . import views
urlpatterns = [
path(“”, views.index, name=”index”),
]
“`
– The next step is configure the global url configurations file to include this URL configuration
– To do this, navigate to the chatbot directory and edit the urls.py file to the following:
“`python
“””
URL configuration for chatbot project.
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/5.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path(”, views.home, name=’home’)
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path(”, Home.as_view(), name=’home’)
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path(‘blog/’, include(‘blog.urls’))
“””
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path(“admin/”, admin.site.urls),
path(“chat/”, include(“chat.urls”)),
]
“`
– Now that that is done, run `python manage.py runserver` and go to `127.0.0.1:8000/chat/` in your browser
– You should see “Hello World”
### Expanding our view with Transformers
– Now we want to expand our view to be able to generate text for us
– First we should decide on a model to use.
– There is a tradeoff between performance and accuracy
– I’ve already picked one out that should run on most people’s computers.
– Unfortunately this means that the model doesn’t offer very detailed or informative responses
– Copy the following into views.py
“`python
# chat/views.py
from django.shortcuts import render
from django.http import HttpResponse
from transformers import pipeline
# Load the model only once when the server starts, not on every request.
chat_model = pipeline(“text-generation”, model=”distilgpt2″)
def chat_response(request):
# This allows us to get User Input from the Form we are going to create
user_message = request.GET.get(‘message’, ”) # Default to empty string if no input is provided.
# We only want to generate a response with our model if the user provides a message
if user_message:
ai_response = chat_model(user_message, max_length=50)[0][‘generated_text’]
else:
ai_response = “Please provide a message.”
# Render the response on the page using an HTML template (we will create an HTML template next).
return render(request, ‘chat.html’, {‘response’: ai_response, ‘user_message’: user_message})
“`
– Now that we have removed the “index” function, we have to modify urls.py to route `chat/` to our `chat_response` view
– Modify urls.py to the following
“`python
# chat/urls.py
from django.urls import path
from . import views
urlpatterns = [
path(“”, views.chat_response, name=”chat_response”), # we are changing this line to route to chat_response instead of index
]
“`
– Now we need to create the template we talked about
– First we need to create a templates directory inside the chat app:
– Run: mkdir templates
– Inside that directory, create an HTML file named chat.html where we will write the HTML code.
– We’ll create a very simple template for our view
“`html

{% if response %}

Chatbot Response: {{ response }}

{% endif %}
“`
– Now we should be able to navigate to `127.0.0.1:8000/chat` and converse with our model
### Improving our view
– Now we should improve our user interface. Here is some code that will do that
– Our new view:
“`python
def chat_response(request):
# Can be used to store conversation history in the future
conversation = []
if request.method == “POST”:
# Get the user’s message from the POST request
user_message = request.POST.get(“message”)
# Generate a response using the transformer model
response = chat_model(user_message)
bot_message = response[0][“generated_text”]
# Add the user message and bot response to the conversation history
conversation = request.session.get(“conversation”, [])
conversation.append((“You”, user_message))
conversation.append((“Bot”, bot_message))
return render(request, “chat.html”, {“conversation”: conversation})
“`
– And this is the new template, with some style changes and preliminary support for conversation history
“`html

Chat Interface

{% if conversation %}
{% for speaker, message in conversation %}

{{ speaker }}: {{ message }}

{% endfor %}
{% else %}

No conversation yet. Start by typing a message!

{% endif %}

{% csrf_token %}

“`
## Final Notes
At this point, you have built a basic AI chatbot using a transformer model, Django backend, and Django templates for the frontend. While this is a simple implementation, it provides the foundation for more complex chatbots and AI-driven web applications.
You can use this as a launch off point to build a similar website on your own or add AI integration to any website you want to build
—
## Further Improvements
Here are some ideas to extend the functionality of what we have built:
1. **Implement User Authentication**:
– Add a login system using Django’s built-in authentication framework.
This allows users to sign in and interact with the chatbot under their accounts, saving their chat history.
2. **Save Chat History**:
– Store user queries and responses in a database so users can review their past interactions with the chatbot.
3. **Deploying to the Cloud**:
– Once the chatbot is complete, you can deploy it to a cloud service like Heroku or AWS to make it accessible online. You’ll need to set up a production environment, including a proper database and static file handling.
– This would also allow you to use more powerful models as they could scale with the hardware that is availible
4. **Frontend Enhancements**:
– You can enhance the frontend experience by integrating a modern JavaScript framework like React or Vue.js
– This would allow you to create a more dynamic experience and enhance functionality
If desired, the ACM can have another workshop that can cover some of these improvements

Automating the Wikipedia Game: Webscraping and Search Algorithm workshop!
2024-10-01 18:00 - 19:00 | CSI 1121, Computer Science Instructional Center, College Park, MD, United States
Meeting recording:https://umd.zoom.us/rec/share/t_YOtZPYssKepphJfaRMSbDb9Vu_cf5mVAuiKwzXRin1bFhCPQQmXryspw_2RIlr.HwS0oZU38GhgryJ5
Password: [REDACTED]

Join us for our next workshop where we will walk you through automating the Wikipedia Game. The Wikipedia game is a simple competition to navigate from one wikipedia article to another, using only links within wikipedia articles. We will be using python with selenium and beautifulsoup to walk through the basics of using and combining different search algorithms and optimizations. At the end of the meeting we will compete to find the shortest path between two articles, with prizes for the efficiency and the least clicks!
6-7 pm
Tuesday Oct 1
Location: Computer Science Instructional Center (CSI) 1121
Github: https://github.com/The-ACM-UMD/Webscraper-Workshop/

Computer Vision and Robotics Lab Tour!
2024-10-17 18:00 - 19:00 | Iribe Ground Floor
Computer Vision and Robotics Lab Tour! Come Join the ACM Thursday Oct 17 at 6:00pm, as we go on a guided tour of the UMD Robotics and Computer vision labs. UMD Researchers will show off their projects, such as robotic arms, underwater computer vision, flapping robots, beamsplitter cameras, and much more. The tour will be an hour and will consist of facilities in Iribe, AV Williams, and the Neutral Buoyancy Research Facility. This is a great opportunity for those interested in getting involved in Computer Science research on Campus!
Please meet us on the Iribe Ground Floor.

Shell Slayer - ACM Halloween event
2024-10-29 18:00 - 20:00
This Halloween, Professor Christopher Kauffman will teach you how to navigate the terminal and use powerful commands to hunt down and slay a rogue daemon that’s wreaking havoc on the ACM’s files and directories. As you dive deeper into the layers of the infernal subdirectories you’ll gain essential terminal skills like navigating filesystems, tracking down mysterious processes, and executing powerful kill commands. No coding experience needed—just your wits and a love for adventure! Come for the code, stay for the frights, and leave with the power to tame the terminal!
October 29 | IRB 0324 | 6:00 PM – 8:00 PM | Zoom | RSVP
