Minitutorials

Presentations from the Conference

Selected presentations from the 2017 SIAM Conference on Computational Science and Engineering have been captured and are  available as slides with synchronized audio. In addition there are PDF’s of the slides available for printing. View presentation slides with synchronized audio.

 

CSE Collaboration through Software: Improving Productivity and Sustainability
View Presentation: Part I
Part II

CSE software—crosscutting technology that connects advances in mathematics, computer science, and domain-specific science and engineering—is a foundation of sustained CSE collaboration and scientific progress. However, the need for increasingly broad functionality on ever more complex computer architectures creates daunting challenges for software development and sustainability.

This tutorial will provide information on best practices in software engineering explicitly tailored for CSE. Goals are improving the productivity of those who develop CSE software and increasing the sustainability of software artifacts. We will discuss practices that are relevant for projects of all sizes, with emphasis on small teams (for example, a faculty member and collaborating students).  

Materials for interactive exercises will be provided via Git. We encourage participants to first install Git on their own laptops and create a free account on GitHub (see https://github.com/).

Part 1:

Part 2:

Organizer:            Lois Curfman McInnes, Argonne National Laboratory, USA
Speakers:            David E. Bernholdt, Oak Ridge National Laboratory, USA
                           Anshu Dubey, Argonne National Laboratory, USA
                           Michael Heroux, Sandia National Laboratories, USA
                           Alicia Klinvex, Sandia National Laboratories, USA
                           Lois Curfman McInnes, Argonne National Laboratory, USA


Exploring the Potential of the PRIMME Eigensolver
View Presentation
PRIMME (PReconditioned Iterative MultiMethod Eigensolver) is a high performance library for solving large, sparse Hermitian eigenvalue and singular value problems. Over the last decade, it has acquired a broad user base for high-end and mid-end applications that require the computation of a small number of eigenpairs. Its success lies on its careful implementation of state-of-the-art methods that converge near-optimally even with limited memory. In addition, it offers a host of unique features that are expertly combined and dynamically adjusted to achieve efficiency and robustness.

Based on an NSF grant, we have extended the functionality of PRIMME to singular value problems, to more robust computation of interior and larger numbers of eigenpairs, and enhanced with new interfaces to problem solving environments, such as MATLAB and python.

This tutorial has three goals.

  1. To expose the potential of PRIMME to current and potential users by explaining how and when to enable each functionality, and the behavior of different methods on different problems and computer architectures.
  2. To demonstrate how to set up and call the library with example interfaces for MATLAB, PETSc, Trilinos, and python, and with threaded and distributed memory parallelism.
  3. To hold a question and answer session with hands-on examples.
PRIMME is available at https://github.com/primme/primme

Organizer:            Andreas Stathopoulos, College of William & Mary, USA
Speakers:             Eloy Romero, College of William & Mary, USA
                            Andreas Stathopoulos, College of William & Mary, USA
                            Lingfei Wu, IBM T.J. Watson Research Center, USA


Interactive CSE with IPython and Jupyter
View Presentation: Part I
Part II

IPython and Jupyter provide tools for interactive computing that are widely used in science and education, and can benefit any CSE instructor, student, or researcher. We will show how to use IPython to improve your interactive explorations in Python, and how Jupyter notebooks enable interactive exploration, teaching, learning, and reproducibility, in Python as well as other languages such as MatLab, Julia, and R.

The first part of the tutorial will focus on using IPython to get the most out of the tools provided by the Scientific Python community. The second part will cover Jupyter more broadly, including how working with the notebook document format can enable shareable, reproducible analyses.

Students should come prepared with the Anaconda Python distribution, or otherwise install common scientific Python tools, such as:


Julia: Technical Computing made Fast, Flexible, and Easy
View Presentation
Julia is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other technical computing environments, yet the under-the-hood architecture is very different from other environments. Julia gains its speed, flexibility, and ease of use in part through multiple-dispatch technology.

We all like fast algorithms. They tend to start off on whiteboards. We then implement them with an idea in mind. Perhaps we will work on a small problem, on a laptop, in double precision, for example. Your supervisor wants it done yesterday, and that is all you see. Then it is successful, and you want it to work on larger problems, on GPUs, in distributed memory, and in quad precision. You want to go into productions and have the solution work well beyond the original prototype.

Julia is of note for its solution to the two language problem, sometimes known as Ousterhout’s dichotomy. In this introductory minitutorial, we will teach Julia, how to use it, its design, and explain why it is becoming the language of choice for Finance, The Internet of Things, Big data, Machine learning, and so much more in Computational Science.

Organizer:      Alan Edelman, Massachusetts Institute of Technology and Julia Computing, USA
Speakers:       Alan Edelman, Massachusetts Institute of Technology and Julia Computing, USA
                      Andreas Noack, Massachusetts Institute of Technology, USA
                      Jarrett Revels, Massachusetts Institute of Technology, USA
                      David P. Sanders, National University of Mexico, Mexico


Version Control with Git
View presentation: Part I
Part II
The Git version control system is now widely used in the scientific computing community, not only for developing code (individually or collaboratively) but also for writing papers and grant proposals, sharing course materials with students and supporting group projects, and a host of other uses.

The first part of this tutorial will introduce the basic concepts of Git and show how easy it is to get started using version control for your own work, on your own computer, as a good way to back up your work, keep track of changes you've made, revert to an earlier version if needed, and improve your ability to reproduce your own earlier work.

The second part will cover more advanced concepts that are useful when using Git to collaborate with others, either privately or as part of an open source software community. We will cover branching, merging, forking, and the use of pull requests. We will also explore the tools available on GitHub, a popular collaboration site that hosts many open source projects.

It is recommended that participants first install Git on their own laptops (see https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) and create a free account on GitHub (see https://github.com/).

Organizer & Speaker:            Randall LeVeque, University of Washington, USA

Contact Us · Donate · Site Map · Join SIAM · My Account
Facebook Twitter Youtube linkedin google+