Computer Science | Grinnell College

Thursday, April 19, 2018
4:15 p.m. in Science 3821
Refreshments at 4:00 p.m. in the Computer Science Commons (Science 3817)

Student presentations on programming languages from summer research with Peter-Michael Osera.

• Scythe—Converting Myth to the Haskell Programming Languages, Liat Berkowitz, Dhruv Phumbhra, Andrew Mack, and Zachary Susag
• Blorca—A Blocks-based Languages for Proof, Myles Becker, Addison Gould, Hadley Luker, and Eli Most
• ToadStool—First-class Typestate via Polymorphic References, Jonathan Sadun

We’ll wrap up our semester with a fun topic for CS Table: Esoteric Programming Languages. These programming languages are intentionally designed to be complex, confusing, or funny, and often offer some clever commentary on the real programming languages we use.

Computer science table (CS Table) is a weekly meeting of Grinnell College community members (students, faculty, staff, etc.) interested in discussing topics related to computing and computer science. CS Table meets Tuesdays from 12:00–1:00pm in JRC 224A (inside the Marketplace). Contact the CS faculty for the weekly reading. Students on meal plans, faculty, and staff are expected to cover the cost of their meals. Visitors to the College and students not on meal plans can charge their meals to the department (sign in at the JRC front desk).

Thursday, November 2, 2017
4:15 p.m. in Science 3821
Refreshments at 4:00 p.m. in the Computer Science Commons (Science 3817)

Building your own programming language and other reasons to go to graduate school is presented by Eric Van Wyk from the University of Minnesota.

To motivate a discussion on graduate school opportunities, Van Wyk will describe some of his group's work on techniques and tools that allow programmers to construct their own programming language, either from independently-developed domain-specific language extensions or by developing language extensions from scratch. Such extensions can provide new syntax and semantic analyses that address the computational task at hand. His specific interest has been on techniques to ensure that one can pick and choose these extensions with some assurance that this collection will in fact work well together.

Research work like this is indicative of what one can do in graduate school in computer science, be it in programming languages, robotics, machine learning, systems, graphics, visualization, bioinformatics, or a plethora of other areas. One has the time and opportunity to dive deeply into an area of interest and push the boundaries of what is possible. Van Wyk will describe what graduate school is like, both generally and specifically at the University of Minnesota and, hopefully, encourage to consider graduate school as part of your future.

At this CS Table we will run and decipher a collection of interesting one line programs. Short programs can be surprising, mind-bending, elegant, infuriatingly clever, or all of the above. We'll follow a relaxed format, where we will look at a new program, run it on a few examples, then try to figure out how it does what it does.

If you have any programs you would like to contribute, please send them to Prof. Curtsinger via email. All programming languages are welcome. We're happy to bend the definition of "one line" in many cases, but do try to stick to programs that are concise.

Computer science table (CS Table) is a weekly meeting of Grinnell College community members (students, faculty, staff, etc.) interested in discussing topics related to computing and computer science. CS Table meets Tuesdays from 12:00-1:00pm in JRC 224B. Contact the CS faculty for the weekly reading. Students on meal plans, faculty, and staff are expected to cover the cost of their meals. Visitors to the College and students not on meal plans can charge their meals to the department.

On November 8 in CS Table, we will discuss the state of JavaScript, the language running inside your browser. This is a programming language that seemingly ignores virtually all of the wisdom garnered in programming language design over the last half century, and yet it has a huge devoted fan base and enormous impact worldwide. We'll talk about some of the amusing quirks in JavaScript, briefly dive into the world in which JavaScript developers must operate, and speculate about why JavaScript has still been so successful. As always, you do not need any experience with JavaScript to participate in this discussion.

Readings:

• First, we have an imaginary dialogue between a new JavaScript user and an experienced developer. How it feels to learn JavaScript in 2016. Jose Aguinaga.
• Next, we have an article that should have the title "Ten astonishing things you never knew JavaScript would do to your values". Truth, Equality, and JavaScript. Angus Croll.
• And finally, the always-hilarious James Mickens on the horrors of web development. This was a suggested read last year, so you may have seen it already. To Wash It All Away. James Mickens. USENIX ;login: logout.

Computer science table (CS Table) is a weekly meeting of Grinnell College community members (students, faculty, staff, etc.) interested in discussing topics related to computing and computer science. CS Table meets Tuesdays from 12:00-1:00pm in JRC 224B. Contact the CS faculty for the weekly reading. Students on meal plans, faculty, and staff are expected to cover the cost of their meals. Visitors to the College and students not on meal plans can charge their meals to the department.

November 5 at 4:15 pm in Science 3821
Refreshments served at 4:00 in the CS Commons
Everyone is welcome

Professor Henry M. Walker will present "MyroC 3.0: Update, Portability, Non-blocking, Threads, Processes, Coordination."

The MyroC project provides infrastructure and materials to allow the use of Scribbler 2 robots to support CSC 161, a course exploring imperative problem solving with C programming. The original work, now designated MyroC.1.0, was built upon a C++ package developed at the University of Tennessee at Knoxville and incorporated into CSC 161 in Fall 2011. Due to issues in portability from Linux to other platforms, work started on a C-based infrastructure in Fall 2013 and was incorporated into CSC 161 in Spring 2015. Through versions MyroC.2.1-MyroC.2.4, the revised package provided several revised commands with both blocking and non-blocking options for robot movement and image display. Although written in Standard C, further refinements could improve efficiency, add functionality, and facilitate portability. This fall, a new MyroC.3.0 is being developed which will refine several previous commands, improve efficiency, and utilize different Standard-C libraries, yielding an infrastructure that will run on both Linux and Mac OS X platforms. Focusing on MyroC.3.0, this talk will highlight several new features and then focus on how concepts from operating systems and parallel processing (e.g., topics covered in CSC 213) are required to implement these new or updated features. Specific topics to be considered will include threads, processes, mutex semaphores, and synchronization via message passing.

The page is currently in very rough form.

Although the philosophical community is not agreed on Putnam's claim that the natural language you speak affects your thoughts, it's clear that the programming language you use affects how you solve problems. (The traditional aphorism for this view is If the only tool you have is a hammer, everything looks like a nail.) Strong computer science students therefore regularly look to learn new languages. This page provides a quick list of programming languages that SamR thinks you should learn.

Essentials

Scheme (or other dialect of Lisp). The functional paradigm is an incredibly powerful approach to expressing algorithms. The abilities to design your own control structures and to use higher-order techniques empowers programmers in many ways. The functional paradigm is also increasingly relevant. For example, Amazon and Google use map-reduce as a core technique in much of their work with large data sets, and most modern languages now seem to include a functional component. As importantly, Scheme has a syntax that easily lets you treat the same expression as either data or code. Being able to switch between models is a transformative way to think about programs.

C. Being able to program in C means that you can start to approach your code at a level close to the machine - you can't program well in C unless you understand memory arrangement. There have been some arguments that students no longer need to handle things at this level, and you can clearly write programs more quickly if you use a higher-level language. Nonetheless, understanding pointers, data representation, and more is useful. C's syntax also influences a large number of languages.

Java.

Postscript. Postscript is a stack-based language (think of reverse Polish notation on steroids) with a focus on making images. You don't need deep understanding of Postscript. But working in a language with this model (and with a fairly simple syntax) can really transform your thinking. Plus, you get to make cool images.

Python or Ruby. Some modern scripting language.

HTML and CSS. These are not programming languages; they are markup languages. But you should know at least one markup language. Knowing HTML also lets you do quick Web consulting jobs. (Yeah, that's a practical issue.)

Additional

TeX or LaTeX. Like HTML, TeX and LaTex are markup languages, not programming languages.

Perl

CSC 312 is a proposed new course in Grinnell's computer science curriculum. It will be a two-credit course that replaces our existing CSC 302, Programming Languages, and CSC 362, Compilers.

Because our multi-paradigm introductory sequence covers many of the core topics in a traditional programming languages course, the new CSC 312 will focus on the implementation of programming languages, primarily through interpretation. It will include some study of syntax (regular expressions and BNF-style grammars) and semantics. It will likely cover the first half of Friedman and Wand's Essentials of Programming Languages.

Current Offering

No current offering

Learning Outcomes

Forthcoming: Learning outcomes from Computer Science Curricula 2013

Previous Offerings

No previous offerings.

On Thursday, April 18, Brooks Davis will discuss the architecture of new computers designed for research into computer systems and networks:

A team of more than thirty researchers from SRI International and the University of Cambridge have spent the last two years developing a pair of clean-slate processor designs and a supporting set of operating systems and programming language extensions. The primary goal of this work is increasing our ability to compartmentalize important -- but risky -- applications such as web browsers at a much finer scale than currently possible. Secondary goals include modernizing the process of hardware design, raising the bar for CPU research, and developing a platform for future work. This talk will discuss our goals in detail and our progress toward building a research platform to support them.

Refreshments will be served at 4:15 p.m. in the Computer Science Commons (Noyce 3817). The talk, “Building a platform for modern systems research,” will follow at 4:30 p.m. in Noyce 3821. Everyone is welcome to attend!

This Friday at Algorithmic Arts (+ CS Table), we will consider some portions of John Maeda's book Design by numbers, which provides a simple programming language for artists.

Meada, John (1999). Design by numbers. Cambridge, MA: MIT Press.

The sections include the preface and introduction, a chapter on repetition, and two chapters on dots. There are also a number of images from the book.

For folks who haven't been to CS table lately, this reading gives us some opportunity to talk about language design issues as well as artistic issues.

Copies of the readings are available outside Professor Rebelsky's office. Kate and Tolu will lead our discussion and have asked participants to consider the following questions:

• How might you create the images from the book (not the ones with the accompanying code)?
• What's the smallest set of functions you would need to make these images?