So he started counting to ten.

I do this myself in almost every meeting I lead. When I ask for questions, I pause and count. Most times, someone speaks up. It feels awkward every single time, and it works almost every single time.

This week, Stephen went past ten and was about to give up. He even messaged me privately: ah well.

The question he’d asked was whether their participation in this program had changed how people thought about AI’s impact on the profession. He’d just demoed a reference agent he built for the Graduate Center—it pulls from LibGuides and the Primo API, and in his tests it outperforms the current chat service. He hasn’t deployed it. He’s still thinking carefully about what it means for an AI agent to be someone’s first interaction with the library.

Then Will started talking. He’s in library school and new to the profession and these AI tools, and he was honest about feeling genuinely unsettled. He could see how well AI handles reference questions so that wasn’t really the issue. What gave him pause was what that efficiency means for the person on the other end. The relationships, the friction, the slow work of getting curious about something—are we moving toward or away from those? “What actually is the point?” he asked. And then, almost in the same breath: it’s also really cool to learn how this works.

The rest of the room had a lot of feelings. Robin talked about technology and humanity in the long view, neither doomer nor booster. Jason reframed it as an information literacy question. Ashley raised the political stakes—what are our obligations as librarians when the tools we’re using are developed by companies making decisions we don’t control? Shamiana said she doesn’t fear AI going away; she worries more about access eventually becoming limited to certain groups.

Nobody rushed to resolve any of it, which felt right.

We’re three weeks into a 16-week program exploring agentic AI and its implications for library work, and I’ve been trying to write something about it before too much time passes and I lose the early impressions.

The cohort builds on something we’ve been doing for a few years through our Alma Extensibility Task Force, a group of CUNY librarians who use Alma’s REST APIs to extend functionality based on systemwide needs. That work has produced small but meaningful things: automations, integrations, configuration improvements that Alma doesn’t natively support. The idea here is to expand that model beyond people who already identify as programmers, and beyond Alma itself.

Thirteen library faculty and staff from nine CUNY campuses are spending the semester building AI-enabled tools to address real workflow challenges. Stephen is leading the cohort, guiding participants through development while keeping a consistent focus on critical evaluation: understanding APIs, interrogating model limitations, assessing risk, and figuring out what’s actually technically feasible versus what’s well-marketed.

The projects reflect the kinds of problems libraries are genuinely grappling with: automating faculty publication tracking for institutional repositories, building accessibility checkers for course content, enhancing discovery systems, streamlining course reserves workflows, developing CUNY-wide tools for data access. People’s technical backgrounds range from complete beginners to experienced developers, which makes the dynamic interesting.

A few of the projects I’ve been wanting to pursue for a while—including externalizing Alma letters into version-controlled infrastructure and standardizing access model descriptions across institution zones—are taking shape within this cohort. These were ideas that had been sitting on a back burner for longer than I’d like to admit. With structured time and tools like Claude Code, they’ve started moving.

My role is mostly scaffolding: structuring the cohort, handling logistics, setting up the shared collaboration space in Microsoft Teams, trying to create conditions where people can experiment without feeling overwhelmed. The Teams space is already more active than I expected: participants troubleshooting installation issues together, sharing resources, asking questions about APIs and workflow automation. Several people are juggling a lot right now, professionally and personally, and they’re still showing up.

We’re only three weeks in, but it’s already interesting to watch.

Every quarter we would review the Alma and Primo VE updates and then repeat the same conversation six different times—once with each of our three working groups and again with our three advisory committees. We’d speculate about what a feature probably did based on screenshots. We’d guess which workflows it might affect. And most of that context never made it beyond the committee representative.

It wasn’t very efficient, and it wasn’t particularly engaging. More importantly, it wasn’t helping the staff across our 30+ libraries feel ready for change.

So in late 2024, we tried something different.

Instead of discussing the release notes in six separate meetings, we started hosting a single open webinar for all CUNY library staff. We call it Shelf Help, and we schedule it the Thursday before Ex Libris pushes updates to production. The timing matters: people get a chance to understand what’s coming before the changes land.

The format wasn’t the only thing that changed, though. The bigger shift was how we prepared.

Rather than summarizing the release notes, we started testing them.

Before each session, we read through the release notes line by line and try the new features in our Alma and Primo VE sandboxes. We decide which changes are actually relevant to our campuses, build examples and walkthroughs, and then share the recording and documentation afterward so people can revisit it later.

Instead of saying, “Here’s what the notes say,” we can say, “Here’s what this does in our environment, and here’s what to watch for.”

We launched the first session in November 2024. A year and four sessions later, we typically see around 70 registrants with roughly 80% attendance. After that first session, we sent out a short survey: 89% of respondents rated their satisfaction as high, and 100% said they wanted the series to continue.

The comments were encouraging:

“Reading a long list of release notes is overwhelming. The format chosen made the information much more accessible and understandable.”

“I really appreciated seeing updates outside my functional area; they still impact the staff that I supervise.”

“I love Shelf Help! I know it takes a lot for the three of you to prepare. I’m grateful.”

It does take time to prepare each session. But it saves far more time across the system. And just as importantly, it reduces anxiety. No one enjoys logging in one morning to a changed interface and a flood of “What the heck happened?” emails.

What this experience has reminded me is that support doesn’t always mean creating something brand new. Sometimes it means taking something dense and scattered—like release notes—and turning it into something shared, practical, and easier to navigate together.

It was… a lot. Especially all at once.

I had been the last new hire in the unit and, as I said, I’d already been there for eight years. I spent a lot of time working on onboarding documentation, trying to make sure I’d covered all the bases.

But when my new teammate started, I quickly realized I’d taken for granted the relationships I already had with my colleagues—relationships built over years of in-person work.

This new hire? She was brand new to my team, brand new to the university, and brand new to New York City.

It was a lot for her, too.

On the advice of my life partner—who works in tech and had been working remotely for years, long before the pandemic—I decided to try a daily co-working hour on Zoom. It’s a time when anyone on the team can show up for questions, work chat, brainstorming, or just to work alongside each other.

It’s not quite a meeting but, in the beginning, it sure felt like one. It was awkward and stiff. None of us knew what to do or how to act. Were we supposed to talk? Stay silent? Look busy?

But persistence paid off. Though I stressed that attendance was optional, I vowed to show up every day. Slowly but surely, we figured it out and settled into a rhythm. People opened up. We reviewed support tickets together. We supported each other through losses. We read through release notes. We laughed. Some days we worked in silence for half an hour, and that was fine, too.

This shared space is now how we start every day. It’s when the whole team gets together—sharing progress, swapping tips, troubleshooting problems, and usually making each other laugh. It sets the tone for the rest of the day. Attendance is still optional, but everyone shows up.

Life with Pi: Microcomputing in Academia

Introduction to single-board computers

Allie Verbovetskaya, Web & Mobile Systems Librarian / CUNY

Before we began with the “formal” presentation, I showed a brief video:

Once the audience was thoroughly confused, I explained that the BeetBox is a quite literal “beatbox” that uses beets as percussion instruments. To achieve this, there are touch sensors in the beets that are wired to a Raspberry Pi. To emit the drum sounds, there is an amplifier and a speaker also hooked up to the RPi. There is a Python program that’s running on the RPi and translating the touches into drum samples. The RPi powers this apparatus behind-the-scenes.

But what is a Raspberry Pi? It is a type of microcomputer. So what’s a microcomputer? It’s a single-board computer that’s small, cheap, and open source. It’s about the size of a credit card and varies in price from $25 up to $100. As such, it’s quite an affordable little machine, containing all the parts of a functional computer: microprocessor, RAM, I/O, power supply, and so on.

The most popular microcomputer—at the moment, anyway—is the Raspberry Pi. It’s $25 for the base model and $35 for the “souped up” version (with more RAM and ports). Another one that comes up frequently is the BeagleBone (brought to you by Texas Instruments, the calculator guys) and it’s quite a bit more expensive at $89. And, the one that’s been around the longest, is the Arduino. They have several boards but the Uno board costs $30.

So now that we understand what they are… what are they for? Well, they can be used for hobbies, such as building a retro arcade gaming station or home brewing. Or they can be used to solve specific problems, such as the RFID pet feeder which was created by someone who needed to feed one of his cats a medicated food and, therefore, could not have his two cats eating each other’s food. (What the creator did was program an Arduino to move the lid on the appropriate food dish based on the cat that approaches the feeding station. This is done via RFID chips that have been attached to the cats’ collars. That way, when Sick Cat approaches the feeding area, her food is made available to her. When she walks away, the lid slides back over so no one cat eat. Then, when Healthy Cat gets hungry, the lid covering her food opens so she can eat. And so on.) Another use is for data collection, such as the Botanicalls kit which allows a user to measure a plant’s comfort levels (moisture in the soil, amount of sunlight, etc.) and tweet “status updates” so you can tell when your plant is thirsty or too hot. (It will also respond to changes in its status, so if it’s thirsty and you watered it, it’ll submit a tweet of thanks.)

So you can begin to see how microcomputers can be used for more than basic tinkering. But you may also be thinking: “That’s great but I’m not a programmer!” And that’s OK! You don’t have to be. Because these microcomputers are open source, there are large and dedicated communities surrounding each. There are plenty of tutorials and guides online—as well as complete projects!—that you can use to get started. You can also seek help from many places, including:

• http://www.adafruit.com/
• http://www.makezine.com/
• http://www.themagpi.com/
• http://www.element14.com/
• http://raspberrypi.stackexchange.com/

But why should you bother to do any of this? Well, there are actually uses beyond recreation. In fact, there is evidence of more and more applications in academia. My colleague Junior discussed uses in the classroom while Robin explained how microcomputers can be used in and for research. Steve discussed the benefits of teaching microcomputing techniques and explain why computational literacy is becoming more important in today’s world. The presentation was then rounded out with demonstrations of projects that each of us had constructed, followed by questions from the audience.

Uses in pedagogy

Junior Tidal, Web Services & Multimedia Librarian / NYCCT

Junior discussed uses of microcomputers in the classroom, including:

• Individual research stations
• Cross-disciplinary projects
• Testing environment for coding projects
• Class/course web server per class/student for ad hoc storage or collaboration
• Paperless archive repository for classes

You can also see Junior’s write-up of our presentation for more information about his section: http://juniortidal.com/2013/12/life-of-pi/.

Uses in research

Robin Davis, Emerging Technologies & Distance Services Librarian / John Jay College

Robin opened with several real-life examples of microcomputers currently being used for research purposes. She then outlined other venues for using single-board computers in and for research:

• Cheap, disposable computing in the lab or studio
• Use inexpensive sensors (e.g., temperature, motion, light, GPS, acceleration, etc.)
• Build prototypes quickly
• Maintain tight control over your machine(s)
• Topic of publication (both scholarly and popular)

For a complete overview of Robin’s contribution to the presentation, see the write-up on her website: http://www.robincamille.com/presentations/microcomputing/.

Computational literacy

Stephen Zweibel, Visiting Lecturer (Librarian) / Hunter College

Steve discussed the importance of computational literacy and how microcomputers can be used to teach this literacy to the next generation of learners. He defined “computational literacy” as the ability to use computers and computational technologies to solve problems, and explained how it supports algorithmic thinking and collaboration.

Demonstrations

• I discussed setting up a personal Dropbox-clone using an ownCloud instance on a Raspberry Pi-powered web server, to be used as a classroom repository or just a safe place to store potentially sensitive materials.
• Junior demonstrated his “auto-citation” project. Using the Open Library API, he created a script that makes it possible to scan an ISBN (or enter it manually) and get a citation (in APA, MLA, and Chicago styles) in return.
• Robin showed a light level logger, wherein she used Python to read data submitted by a 95¢ photocell sensor wired on a breadboard (hooked up to a Raspberry Pi).
• Steve described the concept of a LibraryBox (digital file repository available via its own Wi-Fi signal) and encouraged the audience to connect to his LibraryBox network and download some documents to see his project in action.

Presentation Material

The slides are available online: http://www.robincamille.com/jj/cunyit/.

We also created a handout that was made available at the presentation. You can download it from http://www.robincamille.com/jj/cunyit/handout.pdf.

Colophon

The four co-presenters worked on this presentation collaboratively using git and a shared repository on GitHub: https://github.com/szweibel/CUNY-IT-Presentation. It was the first time any of us has used GitHub in this manner and it proved quite successful.

We used the reveal.js presentation framework for our slides. It’s very easy to use and provides beautiful (and responsive!) slidedecks.

1. Open the Ubuntu Software Center and search for Wine. Install it.

2. From the dash, open Winetricks. Choose “install an app.” Select “adobe_diged” and hit OK.

3. Go through the installation steps. Agree to the EULA. Authorize the computer with your Adobe ID. Close ADE.

4. From the dash, open Winetricks. Choose “select adobe_diged (Adobe Digital Editions)” and then select “Run winecfg.” Under the “Drives” tab, create a new drive letter N (it auto-mounts elsewhere but does not keep changes), add directory /media/nook/ (or the specific location of your Nook on your machine), and change type to “Floppy drive” (under advanced options).

That’s it! You now have ADE 1.7.2 installed on your Ubuntu machine that can be accessed from the dash. Use it to download library e-books, authorize protected PDFs, move books to your Nook*, and so on.

* I’ve only tested this setup with a Nook but I assume the same steps will work for all other ADE-supported e-reading devices.

Resources

• Howto install Adobe Digital Editions on Ubuntu 12.04 and use it with an e-book reader
• Using Adobe Digital Editions to transfer books to the Nook, or a workaround

Note

This post was updated in August 2014 to reflect the new URL for the CUNY Catalog.

Linking to the Aleph OPAC is easy. Linking to a specific search is… well, it’s not as easy and it requires some practice. I’ll explain how to do them both.

Linking to the Aleph OPAC

I don’t know how other institutions do it but, at CUNY, we encourage folks to proxy their OPAC links. This ensures that when a user attempts to view an e-resource, he/she will be able to authenticate himself/herself and gain access to that resource. Otherwise, the user will be stuck behind a paywall.

So what does the URL look like? In its simplest form, it’s just the URL to the OPAC prefixed by the proxy URL:

http://central.ezproxy.cuny.edu:2048/login?url=http://libsearch.cuny.edu/F/

Of course, this is going just through the central office proxy server (ensuring access only to CUNY-wide e-resources, not campus-specific ones) and doesn’t specify a “local base,” or a library scope, so it defaults to the union (or all CUNY libraries) view. To tailor this link to your specific library, you will need to know your college’s proxy server and your Aleph local base. Then you’ll end up with a link that looks like this:

https://login.remote.baruch.cuny.edu/login?qurl=http://libsearch.cuny.edu/F/?func=find-b-0&local_base=BARUCH

Using this properly formatted URL, your patrons will be defaulted to their local library search scope and they will be pinged for authentication when they reach a licensed e-resource.

Linking to a specific search

But what about when you want to link to a specific search? For example, a faculty member would like to link to all the library’s holdings of Junot Diaz’s work from her Blackboard course site. How can we help her with this?

It’s not enough to just do a search and then copy & paste the resulting URL. You will be stuck with a unique session ID in that URL that will expire and cause the link to default to the basic search screen. This then leads to confusion and frantic emails. The simplest solution, then, is to take that search result URL…

http://libsearch.cuny.edu/F/7C3C7V4U65QEI7DY79FFUP7LIKY3K1289DEAALI48L6LJF4D34-13445?func=find-e&find_scan_code=FIND_WAU&request=junot+diaz&local_base=LEHMAN

…and remove the session ID. In the URL above, it’s the gobbledygook (yes, that’s the technical term for it) after the F/ and before the ?func. So the new, persistent (and proxied!) URL will be:

http://memex.lehman.cuny.edu:2048/login?url=http://libsearch.cuny.edu/F/?func=find-e&find_scan_code=FIND_WAU&request=junot+diaz&local_base=LEHMAN

There are several things to note here:

• This is scoped to Lehman College and goes through their proxy server. If you want to narrow it to your own library (or broaden it to all the CUNY libraries), choose the appropriate Aleph local base and proxy server.
• The find_scan_code parameter has the value FIND_WAU, which means we’re searching for a keyword (that’s the find part) in the author field (that’s the wau part). If you need to perform a different search, you will need to select a different search type (or value for the find_scan_code parameter):
  • FIND_WRD: All Fields
  • SCAN_TTL: Title begins with
  • SCAN_AUT: Author, last name first
  • SCAN_SUL: Subject begins with
  • FIND_WTI: Keyword in title
  • FIND_WAU: Keyword in author
  • FIND_WSU: Keyword in subject
  • SCAN_SUC: Children’s subject begins with
  • SCAN_SUM: MeSH subject begins with
  • SCAN_SHL: Call number
  • SCAN_ISBN: Browse ISBN
  • SCAN_ISSN: Browse ISSN
  • SCAN_SYS: Browse Aleph system number
• The request parameter is where you enter your query. Spaces need to be replaced with a plus sign (+). In our example above, notice how the query reads junot+diaz.

It is also possible to construct a much more complicated URL: https://login.remote.baruch.cuny.edu/login?qurl=http://libsearch.cuny.edu/F/?func=find-c&ccl_term=wow%3Dbb%20and%20wti%3DAmerican+directories&local_base=U-JOURNAL

Here, instead of a find_scan_code, we’re using a ccl_term (Common Command Language), which is a way to construct a more complex search in the URL. Furthermore, the query for the 2-letter OWN code (wow=bb) and keyword in title (wti=American+directories) used in the ccl_term parameter in this example includes escape sequences for some of the following characters:

• = represented as %3D
• " represented as %22
• ( represented as %28
• ) represented as %29
• (space) represented as %20

These characters have to be escaped in the ccl_term parameter. For a list of the CCL terms, see the CUNY Catalog help files.

Embedding a search box

Instructions for embedding a search box to the CUNY Catalog from anywhere (e.g., LibGuides, SerialsSolutons, etc.) are too long to include in this post. However, they are available on the Support @ OLS website.

It collects information in hidden input fields so all the user sees is a “Submit” button. This is done with a Google Form and some JavaScript. To implement similar functionality for your EZproxy server:

1. Create a Google Form with 4 fields: referring URL, user agent, requested URL, and requested host. (Don’t spend too much time picking a template: no one will see this form since we’ll be embedding it into EZproxy.)
2. Create a new spreadsheet that will save the responses (by clicking on the “Choose response destination” button in the toolbar) and click on the “View live form” button.
3. Right-click and view the source code of the form. Find the following items:
   • <form> tag
     note the URL that is its “action” parameter (in the form of https://docs.google.com/forms/d/[FORM_ID]/formResponse, where [FORM_ID] is a long string of characters)
   • <input> elements
     note the name of each (in the form of entry.[xxxxxx], where [xxxxxx] is a string of numeric characters)
4. In your EZproxy docs directory, edit needhost.htm and insert the following into the body of the page (replacing [FORM_ID] and entry.[xxxxxx] with the names from your form):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<h3>Oops!</h3>
<p>There appears to be a problem with the library's setup of the material you are trying to access. The host <em>^H</em> is not recognized by the proxy server.</p>
<p>If you arrived here by following a link and believe this resource should be accessible, let us know of this error by hitting the "Submit" button below:</p>
<script type="text/javascript">var submitted=false;</script>
<iframe id="hidden_iframe" style="display: none;" name="hidden_iframe"></iframe></pre>
<form id="needhost_form" action="https://docs.google.com/forms/d/[FORM_ID]/formResponse" method="POST" target="hidden_iframe">
	<!-- Below: Referring URL -->
	<input dir="auto" name="entry.[refurl]" type="hidden" value="" />
	<!-- Below: User Agent -->
	<input dir="auto" name="entry.[usragt]" type="hidden" value="" />
	<!-- Below: Requested URL -->
	<input dir="auto" name="entry.[requrl]" type="hidden" value="^V" />
	<!-- Below: Requested Host -->
	<input dir="auto" name="entry.[reqhst]" type="hidden" value="^H" />
	<script>
		document.forms["needhost_form"]["entry.[refurl]"].value = document.referrer;	// referring URL
		document.forms["needhost_form"]["entry.[usragt]"].value = navigator.userAgent;	// user agent
	</script>
	<input name="draftResponse" type="hidden" value="[]" />
	<input name="pageHistory" type="hidden" value="0" />
	<input id="submit_btn" name="submit" type="submit" value="Submit" />
</form>	

Note the <script> and <iframe> tags in the code. What are they?

• Lines 4-6
  • Upon hitting the “Submit” button in a Google Form, users are taken to a Google confirmation page. We want the user to stay on our site so we have to force this behavior on the EZproxy server.
  • By creating a Boolean variable (var submitted=false;, line 4) whose value will change upon the form submit (<form [...] onsubmit="submitted=true;">, line 6) and trigger a script that will change the window’s location (<iframe [...] onload="if(submitted) {window.location='public/needhost_submit.html';_">, line 5) to a page that you will have created and populated with a nice message, assuring the user the issue will be addressed posthaste.
• Lines 15-18
  • We fill two of the <input> elements with data we grab from the browser: referring URL (line 16) and user agent (line 17).

Et voilà! You now have EZproxy error reports, submitted by users trying to access actual resources, in a spreadsheet in your Google Drive account:

By default, you do not get email notifications when a form is submitted. You can turn on this functionality in the Google Spreadsheet but all it will do is inform you when a user has submitted the form, without actually providing you with the form data in the email.

To overcome this, we’ll create a script that will send the results to you by email as soon as a user submits the form. In the response spreadsheet, go to Tools > Script editor > Blank Project and paste the following code into the editor (replacing placeholder variable values with your own):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function sendFormByEmail(e) {
	var emailSubject = "Request to add host to EZproxy config.txt";  
	// Set with your email address or a comma-separated list of email addresses.
	var yourEmail = "[EMAIL_ADDRESS]";
	// Set with your spreadsheet's key, found in the URL when viewing your spreadsheet.
	var docKey = "[FORM_ID]";
	// If you want the script to auto send to all of the spreadsheet's editors, set this value as 1.
	// Otherwise set to 0 and it will send to the yourEmail values.
	var useEditors = 0;
	if (useEditors) {
		var editors = DriveApp.getFileById(docKey).getEditors();
		if (editors) { 
			var notify = editors.join(',');
		} else var notify = yourEmail;
	} else {
		var notify = yourEmail;
	}
	// The variable e holds all the submission values in an array.
	// Loop through the array and append values to the body.
	var s = SpreadsheetApp.getActive().getSheetByName("Form Responses");
	var headers = s.getRange(1,1,1,s.getLastColumn()).getValues()[0];
	var message = "";
	for(var i in headers) {
		message += headers[i] + ' = '+ e.namedValues[headers[i]].toString() + '\n\n'; 
	}
	MailApp.sendEmail(notify, emailSubject, message); 
}

Click File > Save and give the project a name (such as needhost_notify). Go to Resources > Current project's triggers. Click “No triggers set up. Click here to add one now.” to add a trigger. Ensure the following values are selected in the drop-down menus: sendFormByEmail, From spreadsheet, On form submit. Click “Save.”

A message will be shown to authorize the script; click “Continue.” Read the terms and click “Accept.” It will approve the authorization for the trigger and bring you back to the code editor. You can now close the editor and go back to your spreadsheet because you’re all set!

You should now have a form, embedded in your EZproxy’s needhost.htm file, that users can submit to self-report problems accessing resources. Their responses will be logged in a spreadsheet in your Google Drive account and emailed to you upon submission. Go forth and troubleshoot!

Resources

• NeedHost alerts via Google Form
• Tip: Making a Google Doc submission form email you the results

One of the biggest Y U NO WORK!? moments was trying to figure out why users’ personal contact forms were not conforming to the friendly URL pattern I’d set up with Pathauto:

No matter what I did, the users’ contact forms were always located at user/[uid]/contact (and not at the desired users/[user:name]/contact). The thing that confused me the most, though, was that this wasn’t a problem in our current D6 instance and that’s because Pathauto 6.x-1.6 contains a separate field for user contact forms paths:

Frustratingly, there’s no such field in Pathauto 7.x-1.2.

…There is, however, Sub-pathauto— a totally separate module that does exactly what it sounds like. It creates sub-path URL aliases for patterns created with Pathauto. I installed it¹] as soon as I learned about its existence:

$ drush dl subpathauto
$ drush en -y subpathauto
$ drush cc all

And, presto! Users’ personal contact forms are now at the desired users/[user:name]/contact location. (However, they are also at the previous—and undesired—user/[uid]/contact location so be sure to install Redirect to remove the duplicated URLs.)

Now why didn’t Pathauto for D7 come standard with this functionality?

The videos turned out exactly as I had envisioned them and I am incredibly proud of all the work my colleagues and I put into them. The website on which these videos are displayed also allows students to email the videos to themselves for later viewing, which will be crucial at the conclusions of the library’s information literacy workshops.

This project was truly a joint effort. In addition to the staff in the library, I collaborated with the campus Multimedia Center to record the videos and with the college IT Division to create the website and mail form. I feel extremely grateful to have gotten the opportunity to work cooperatively with these talented folks across the Lehman College campus.

I am no longer the Instructional Technologies Librarian at Lehman College but I am still on board as an adjunct. (I am also an adjunct in the library at City Tech.) I will no longer be contributing to this or the webcomic project but I am excited to see these tutorials grow and evolve. They’re like my children and this is akin to watching them grow up. It’s bittersweet.