SA2C Tech Chat

Out of the box, SSH can be awkward to use, requiring long arcane connection strings to be typed on every login, and constantly-shifting passwords to be remembered. In this Tech Chat, Ed will introduce some of the features in OpenSSH that can make connecting to SSH less of a chore. Hide abstract

In this Tech Chat, Aleksandr will talk about Arm's solutions for HPC, their software ecosystem; Machine Learning Basics, Convolutional Neural Networks, and image classification; Introduction to HPC-ML; a Short overview of TensorFlow and its backend; an overview of Catalyst, and HPC-ML benchmarks; Scaling results for HPC-ML; Profiling results; Where are the hot-spots; Multi-threading in TensorFlow; and, ArmPL sgemm for TensorFlow backend Hide abstract

When working with a supercomputing cluster it can be frustrating at times to have to wait for your job to start. The system responsible for this works according to a small set of rules that can hopefully be explained in a short tech chat like this. We are going to focus on the algorithm used by the SLURM workload manager (Simple Linux Utility for Resource Management) for scheduling jobs and discuss the factors in the priority formula, the backfill passes, and the tools that can help us understanding what is going on. Hide abstract

Symbolic computation is a fascinating topic in computational mathematics. It is a paradigm in which the users work with symbols and semantics rather than numerical values. In this tech chat, we will explore SymPy, an open-source Python library for symbolic computation. We will learn how to use SymPy for algebraic manipulation of polynomials, finding roots of equations, computing derivatives and/or integrals of symbolic expressions, and for applications in tensor calculus using the index notations. This talk will be useful for all those interested in exploring Python and computational mathematics. Hide abstract

Mark will introduce the Python packages requests and Beautiful Soup, and show simple ways to combined them to download scrape data from html websites. Hide abstract

The performance of supercomputers depends on a number of factors. Many of these are characteristics of the machine—for example, the processor speed, the memory bandwidth, the interconnect. But equally important are characteristics of the application, and in many cases the specific problems that the application is solving. BSMBench and SOMBRERO are two benchmark suites, tools used for assessing the performance of a particular problem or piece of software on a particular piece of hardware, developed at Swansea University, which can assess the performance of supercomputers when running problems in lattice gauge theory, and beyond. In this talk, Ed will first introduce the basics of lattice gauge theories for the unfamiliar, then introduce the HiRep suite used to simulate these theories computationally, and then discuss the approaches taken by the two benchmark suites to characterise machines’ performance, and present some characteristic results on various supercomputer platforms Hide abstract

As high-performance computing has evolved over the last few decades single-core CPU performance has remained fairly flat as More’s law has essentially reached its limit. Instead, the emphasis has been placed on parallel computing with many modern machines making use of four or more CPU cores working on problems in parallel to achieve significant speed-up for certain tasks. In this SA2C Tech chat, we will cover using the multiprocessing and Threading modules for writing parallel programs using the Python programing language. We will briefly discuss the pros and cons of this approach along with some examples of the various methods provided by these modules and some tips/things to look out for when using them. A basic understanding of programming in Python is all that is necessary. If you have attended our one-day workshop on Software Carpentry you should be well equipped to follow along and this will be a useful talk for taking your Python/software skills further. Hide abstract

Clustering algorithms (CA) are a part of machine learning, and are an essential tool for data mining. Some general-purpose CA are readily available in open source libraries, like scikit-learn for python, while other ad-hoc algorithm have to be coded from scratch. In this Tech Chat a number of CA from the scikit-learn Python library will be briefly reviewed, with some simple applications to econometrics. For the rest of the talk we will focus on a specific algorithm for trajectory-based clustering, describing the motivation framework and highlighting the most important implementation details and challenges. Hide abstract

sort and join are two frequently-overlooked shell commands, which together can be used to get SQL join-like functionality for plain text files at the command line. This will be a short talk introducing their usage, followed by time for questions and general discussion. Hide abstract

The Supercomputing Wales project has as one of its goals increasing the public understanding of High-Performance Computing in Wales. To further this ambition, the RSE team at the Swansea Academy of Advanced Computing agreed to run a stand at the Swansea Science Festival 2018. To this end, we assembled a cluster of 16 Raspberry Pi single-board computers, and developed software to demonstrate some of the principles of parallel computing as well one of as the types of problem that the supercomputer in Swansea is used for in research. In this talk, first presented at the RSE Conference 2019, we will describe the process of designing and constructing both the hardware and the software, and some of the challenges we encountered along the way, as well as discussing how well it works as a scaffold to discussions around parallel computing with members of the general public. Hide abstract

In this talk, Michele will introduce Pandas, the dataframe-based data analysis for Python, and how it has improved his data analysis workflows. Then, he will present a case study on how he has made use of Pandas in econometrics and geographical economics, with a look at some of the statistical techniques and challenges associated with this. Hide abstract

An introduction to one of the oldest languages still in common use, and a comparison to the features of the popular Python lanaguage. The talk will consist of an introduction to the syntax of Lisp, in a simple accessible format. Hide abstract

In this talk, we will have a short introduction to PETSc. We will look at some important data structures and utilities in PETSc that are very useful for computational scientists interested in developing codes for HPC architectures. We will look at some important aspects of PETSc that makes it so powerful and flexible. Hide abstract

In this talk, Ed will walk through the process of implementing MPI into a piece of Lattice Field Theory software written in Fortran. Along the way, various parts of the MPI standard not typically visited during tutorials will be described. Some performance data will also be shown. Hide abstract

In this week TechChat we are having a look at VTune and ITAC, the notorious performance analysis tools by Intel, using the profiling and optimisation of a Lattice Field Theory code as an example. Hide abstract

The module command is frequently provided on HPC systems to give access to a wide array of often mutually incompatible software, but sometimes it has limitations which seem restrictive or quirky. In this Tech Chat we will explore the structure and mechanisms of the underlying implementation of the module command to find the origin of these limitations. Hide abstract

In this TechChat, Michele will show some examples of GPU programming, making use of CUDA, OpenCL, and OpenACC. He will also show an example of a very simple OpenGL application. Hide abstract

Graphical Processing Units (GPU) are frequently used to solve computationally intensive problems. They are well suited for computationally intensive problems, such as machine learning, but the power comes with limitations. I will give an overview of the history and the technical details of modern GPUs and contrast them with other computing platforms. Hide abstract

We introduce and define a number of different programming paradigms, and briefly discuss some possible merits and drawbacks of each. An extended group discussion will give an opportunity to specify options, preferences and experiences with various paradigms. Hide abstract

Ever wondered how git really works? Where and how does it store it's data and what exactly is being stored? Can we peek into the database at files, commits, branches and directory trees? What information is git storing and how? How is this different from other version control systems? We take a peek under the hood to see what and how information is being stored and manipulated in our day-to-day git usage, and how this can leads to being more productive with git. Hide abstract

Which open source license should you choose when you publish your scientific code? There are several public software licenses giving slightly different permissions and imposing slightly different restrictions to using your code. I will introduce the most common options, from a public domain declaration to no license at all, and outline their features and problems for scientific code. Hide abstract

One of Python's most attractive features and the source of much of its power is its extensive library of third-party modules and libraries. However, when too many libraries are installed, it becomes difficult to manage keeping compatible versions, and to move applications between machines. In this Tech Chat, Ed will introduce some of the tooling available to make these experiences easier, including conda, virtualenv, and pipenv. Hide abstract

Using well known patterns in designing software can help greatly in developing code that is easier to maintain, to extend and to understand for other people. In this Tech Chat I will discuss some of the most common ones in the category of "Structural Patterns" and compare them. Hide abstract

A good build system is essential for any large scale project. If set up properly it makes it easy to compile often, which in turn incentivises active debugging, frequent unit testing, and making sure all your git commits compile. My question for the talk is this: If they are such important tools, and have been around for more than 50 years, why are there no good ones? In the talk I will highlight some of the things that are important to me and go through some scenarios I have encountered recently. I will also talk about the systems I have personally used, systems I have researched, and most importantly, about Bazel, the newest tool in my toolbox and how it solves some of my grievances (and not others). Hide abstract

Sometimes Python is too slow, and numpy has just not got the feature you need. In this talk I'll show how to use Python ctypes to import your functions written in C. Alternatives will also be reviewed. Hide abstract

The compiler used to turn human readable code into a machine readable object file naturally has an effect on performance. We usually remember to tune compiler flags to fit the application, but the different compiler versions can behave differently. I study the performance of a well tuned HPC application when compiled with different versions of gcc, clang and the Intel compiler. Hide abstract

First introduced in the 1970s, the Model-View-Controller and its variations are arguably the the most popular and long-lived design patterns for building modular, maintainable and extensible interactive applications for desktop, web and mobile. We introduce the fundamental concepts necessary to start using the pattern, and outline its strengths and weaknesses. Frameworks which leverage concepts from MVC, such as Qt/PyQt and Rails, will be introduced and the advantages and limitations of MVC design discussed. Hide abstract

Background compilation, incremental compilation, on-the-fly syntax checking, or "red squiggles in your editor" have been available for almost two decades, but are still sadly underused by many developers, in particular those who do not use an IDE where they are enabled by default. In this Tech Chat, I will briefly outline the history of the red squiggle, show how you can get them in your editor, and try to convince you that it is something you want to do. Hide abstract

At this TechChat, we'll take a look at spacemacs, a popular new configuration for the emacs editor. This provides, amongst other things, a near-identical replication of vim within emacs. Seasoned vim users can access unparalleled configurability and extendability of emacs, without the need to learn new keybindings for editing. The configuration is designed to make emacs easily discoverable and make common configurations simple. Vanilla emacs users can have the convenience of simple modular configuration, whilst taking advantage of a powerful modular configuration and switching between vim and emacs style with a single keystroke. Hide abstract

The Microsoft HoloLens is an self contained augmented reality headset and computer. The College of Science and Swansea Academy of Learning and Teaching have invested in a number of devices to explore potential applications to teaching and learning. In this talk I will be sharing my experiences developing prototypes for the HoloLens. I'll focus on the capabilities of the device and the challenges of creating augmented reality experiences in environments you've never seen. Hide abstract

Continuing on the theme of Machine Learning, I will give a brief technical introduction to Artificial Neural Networks and Deep Learning. Starting from the simple artificial neuron, I will describe the general construction of classifiers, generative models and recurrent neural networks, as well as training the networks using Gradient Descent Algorithms. Hide abstract

In this Tech Chat I will discuss foundations and problems in Machine Learning in its three main flavours (supervised, unsupervised and "reinforcement"), in the hope of giving the context for future Tech Chats on more specific areas and techniques. I will also try to give a historical perspective and some examples in order to better illustrate some basic principles, with the aim of sparking discussion and experience sharing in the audience. Hide abstract

What do you do when your Python projects become too large to manage by simply sticking a bunch of Python files in a folder? How can you nest packages to best make your code maintainable and reusable? In this talk I will discuss some best practices and strategies to structuring large projects, drawing from case studies in the Python standard library. Hide abstract

The talk will showcase a powerful but little known Linux utility, strace. The command belongs to a special group of tools which operate on other commands or executables. It reports system calls made and signals received by the application under scrutiny and is useful for debugging, trouble shooting, or analysing activity of a program without available source code. The presentation will focus on a particular use case for exploiting strace for tracing I/O activity. Basic usage examples of strace will be shown, demonstrating how to make sense of the output given by the command. Hide abstract

I will be talking about Jenkins, a continuous integration system with a user friendly web interface. Jenkins automates compiling, testing and deploying software and can be a very useful tool for improving code quality and preventing bugs from reaching production systems. I will show how I used Jenkins to build and test a web portal for experiment management at the National Plant Phenomics Centre in Aberystwyth. I would also be asking the question of how appropriate continuous integration is in research software where developers often work alone and the number of users is small. Hide abstract

In this talk I will give an introduction to template metaprogramming in C++, focusing on what it is good for and which kind of issues one normally would choose this particular tool from the C++ toolbox to solve.

We will go through the list of concepts and the terminology commonly in use when writing metaprograms, and the talk will feature plenty of example, some of which we will analyse in depth to understand what the compiler is doing. We will also look at libraries to facilitate working with TMP, more specifically using boost::mpl. Finally, if time permits we will have a look at how these ideas can be used to write what is known as "expression templates", which is a variant of lazy evaluation at compile time. Hide abstract

The talk will introduce and motivate several design features of current chips and operating system features. These include an accessible introduction to features of many modern processing units, such as: CPU caches, pipelining, superscalarity, branch prediction and speculative execution. Only a very basic familiarity with common programming concepts is assumed. The interplay between these chip design choices which resulted in the recent, highly-publicised Meltdown vulnerability in almost all recent Intel chips will be explained at high level, without assuming knowledge of any specific language. Hide abstract

In this talk I will give a thorough introduction to templates in C++. This will include topics such as: what a template is; what kind of templates are there; what are the rules for template lookup; when are templates instantiated, and how can you affect this; what is a template specialisation, and what are the restrictions. If time permits we will also talk about the "recently" introduced concept of variadic templates and how these can be used to replace C's infamous varargs.

The talk is intended to both introduce the rules of templates to the audience, push the "all errors at compile time"-mindset, as well as build a solid foundation on which we will base the next talk in the series, which is on template metaprogramming. Hide abstract