- Intro to Quantum Computing Algorithms
Presenter: Dan Muldrew I’ll first introduce quantum computation with a motivating analogy. Then explain some of the computational advantages of manipulating information at the quantum level, such as superposition and entanglement, compared to classical computation. Finally, I’ll talk about how proposed quantum languages, such as IBM Qiskit and Q#, are designed to take these features into account, within the context of Shor’s factoring algorithm (and potentially other algorithms as well), which essentially started the field. * For IBM Qiskit, here is an implementation of Shor’s algorithm: https://github.com/Qiskit/qiskit-tutorials/blob/master/community/awards/teach_me_quantum_2018/intro2qc/8.Shor's%20algorithm.ipynb * For Q#, we'll look at simpler algorithms. * I’ll run some of the algorithm implementations on a Raspberry Pi---which include a free copy of Mathematica * For those interested in a classic paper on quantum computing, here is one I'll be presenting the following night at the Papers We Love @ Seattle meetup: https://arxiv.org/pdf/quant-ph/0010034.pdf
- Seven More Languages in Seven Weeks!!
Group discussion. A follow-up to last month's fascinating discussion of the original book, this meeting focuses on the Seven More Languages in Seven Weeks, by Bruce A. Tate, et. al. Languages covered in this sequel are Lua, Factor, Elm, Elixir, Julia, miniKanren (?!), and Idris. We'll build on the previous month's theme, comparing language features and getting better understanding the landscape of programming languages out there, including what patterns you can bring home to your own work. If you'd like to do a mini-presentation on one of these languages, feel free to post a note on the discussion page for this meeting.
- Seven Languages in Seven Weeks!
Group discussion of the book Seven Languages in Seven Weeks, by Bruce A. Tate. Languages covered are Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell. What are the driving forces in each language's design? Why were these languages covered, and how are they positioned in the programming language ecosystem? How do they compare with others, or with your favorite language on features like expressiveness, run time, execution time, ease of concurrent & parallel execution, testing, verification, deployment, etc? (Comparison matrix?) Perhaps this will help you see new possibilities for patterns in those languages you use regularly. Reading the book beforehand is encouraged, but obviously not required. If you'd like to do a mini-presentation on one of these languages, feel free to post a note on the discussion page for this meeting.
- Exploring the type system of ReasonML/OCaml
- Understanding Git Internals
Speaker: Rachel Singh Git can be hard, especially without a fundamental understanding of what the Git command is actually doing. This talk provides an in-depth look at the intent behind Git and offers pointers to navigate situations such as detached HEAD pointer, prevent local changes from being clobbered, determining best undo practices, local commit tree clean up and merge strategies. Topics covered will benefit development and deployment practices for both Git beginners and daily users.
- The Julia Programming Language
Speaker: Elliot Saba, Sr. Research Engineer at Julia Computing Description: The Julia language defies the typical tradeoff of high performance against high-level features. Providing the best of both worlds through intelligent language design and modern compiler technology, Julia forms the foundation for a thriving ecosystem of packages for machine learning, data science, parallel/heterogenous computing, data visualization, scientific analysis and more. Elliot will give an overview of the Julia language and explain how it is able to give both a pleasant and productive programming experience while still achieving speeds competitive with best-in-class languages such as C/C++/Fortran.
- (1) Microservices for cross-language development; (2) Probabilistic programming
NOTE DATE CHANGE: Now scheduled for Nov 7th. Talk #1: Using microservices, containers, and serverless hosting for seamless cross-language development (including Machine Learning) Presenter: Jon Peck, Developer Advocate & Software Engineer at Algorithmia, Inc. When selecting components & modules, your decision should be based on quality, not implementation language -- but until recently, it wasn't easy to integrating code across many languages and host them all in a scalable environment. The rise of containerized microservices has changed all that. Learn about a paradigm for seamless composition of code between any set of languages and frameworks, and one live implementation which lets you host them all in a pay-per-second elastic environment. Bonus feature: a marketplace for Machine Learning services which allows you to use advanced ML with zero background (or local dependencies), or share your own ML models with other developers. Talk #2: Adding probabilistic programming languages to your data pipeline. Presenter: Jay Coskey Probabilistic programming languages separate the description of probabilistic models from statistical inference performed on them. Since these are key facets of Machine Learning (ML), probabilistic programming languages can play a significant role in ML. Generally, an Inference Engine helps dramatically shrink the (domain-specific) portion of the code that still needs to be written. DARPA sponsored an initiative from[masked] called the Probabilistic Programming for Advanced Machine Learning (PPAML). It had the goal of making ML apps easier and faster to write, and making the results more powerful and robust. Some of the most popular probabilistic programming languages and frameworks are Stan (C++), PyMC3 (Python), and Edward/InferPy (Python/Tensorflow).
- Correct and Efficient Code using Dependent Types and Gadts
Presenter: Michael Kerekes, creator of the Mana programming language Dependently typed languages have two major novel features: (1) types are first class, and (2) types can depend on arbitrary values. First class types can be passed as parameters, returned from functions, and stored in data structures just like any other value. Types can be calculated from other types or normal values. These features allow almost any property of code to be checked statically at compile time, which in turn allows runtime checking of those properties to be removed. I have recently added dependent types to the Mana language and I will give a few examples of their use: * an efficient interpreter for an expression language. The strongly typed AST makes it possible to remove all runtime type checks. * length indexed lists that require no runtime bounds checks * a strongly typed implementation of printf that statically calculates it parameter types from the format string at compile time