Thinking with Arrays
Building on Aaron's introduction to APL, Marshall will take a broader view of APL and discuss what the concept of a (multidimensional) array means to array programmers and why we might want to base entire languages on this concept. He will show how methods from the array paradigm can be used even when programming in functional languages, focusing on one APL operator rarely appreciated outside of the array community: the outer product. Finally he will discuss a number of problems taken from mathematics and practical programming and show how APL thinking can simplify and unify concepts: all of the problems are solved using the same simple pattern involving outer products!
Outline/Structure of the Talk
- What's an array? What's array programming?
- The outer product in APL
- Using array programming in functional languages
- Thinking more effectively with arrays and outer products
After this talk, participants should understand the basis of the array programming paradigm and how it relates to the functional paradigm. They should understand when array techniques are appropriate and understand how the array paradigm can make concepts simpler and reveal previously hidden connections.
Users of any programming language who want to improve their effectiveness by using array techniques.
Prerequisites for Attendees
Aaron Hsu's talk "APL Training Wheels" or a basic knowledge of APL from other sources.
schedule Submitted 2 years ago
People who liked this proposal, also liked:
Aaron Hsu - Programming Obesity: A Code Health EpidemicAaron HsuComputer ResearcherDyalog Ltd.
schedule 2 years agoSold Out!
Programs are getting fat. They're becoming slow. They're taking up more computing resources. They're getting harder to maintain and more complex from the ground up. Layer upon layer of sophistication is causing us to lose our ability to predict what software will do. Where's that bug? Why is everything going so slowly? Am I even using the right data structures? Where's that important point in the documentation again?
What's happened to us? In this meta-dive into the nature of our approach to programming, we will explore some of the dangers of our current approaches to programming and the how/why of our current programming obesity problem. We will look at real case studies and see just how bad the situation can be.
But we will also explore how we can battle these sources of obesity. In this passionate plea for code that we can gain control over again, we will look at examples of how we can return to a state of high-performance on all levels, from code size to code scalability. We will look at the principles that can help us to reach leaner, more efficient, more usable, less buggy code. We will hopefully find some light at the end of the tunnel, and how we can change our outlook on programming to push ourselves towards code that benefits not only ourselves, but also those that will come after us.
Alexander Granin - Hierarchical Free Monads and Software Design in Functional ProgrammingAlexander GraninHaskell ConsultantIE Granin A.S.
schedule 3 years agoSold Out!
Functional Programming is going through the same process of rethinking as Object Oriented Programming has passed already. FP today is not only something mystical, something barely applicable for day-to-day tasks, but rather a whole philosophy of building big, complex applications, with own tools, approaches and methodologies. We can see a lot of ideas about software design and architecture emerging from the FP community: talks, books, articles. We’re actively discussing Final Tagless, Free Monads, effect systems and other approaches, but it seems the theme not yet covered and we don’t know about possibilities we have.
In this talk, I’ll tell you about the power of Free Monads in building complex applications in Haskell and PureScript. These applications will be satisfying the requirements like maintainability, testability, simplicity. You’ll know how to create a safe concurrent application state, how to divide the application into layers and how to keep the code sane. In fact, you can do the same with Final Tagless or extensible effects, but the approach with hierarchical Free Monads has some specific properties making it the best tool to separate concerns and create a very interesting eDSLs with different semantics.
I’ve used these ideas to build software for different companies, including Juspay (Bengaluru), Restaumatic (Poland), Enecuum (Hong Kong). We’ve created several interesting technologies that were not possible to make without Free Monads. Some of them are open sourced.
Anne Ogborn - Introduction to Logic Programming and SWI-PrologAnne OgbornLogic ProgrammerDataChemist.com
schedule 2 years agoSold Out!
As machine learning matures, it is becoming obvious that we need explainable solutions. As functional programming matures it becomes obvious that we need inference and nondeterminism. And linked open data demands reasoning. This all day workshop will introduce the logic programming paradigm, in which programs are expressed as a set of logical rules and executed by finding proofs of queries.
SWI-Prolog is the most highly developed and widely used language for logic programming.
The language, which has been in continuous use in academic research settings since it's invention in 1972, provides unparalleled power. Many problems which would be difficult to express in other languages are simple in SWI-Prolog. SWI-Prolog is a 'batteries included' modern language, ready for real world tasks like web development and process control.
In this dynamic hands on workshop we'll learn the basics of SWI-Prolog, and look at some of the amazing things it can do.
Harmeet Singh - Type System: The Beauty And The BeastHarmeet SinghModule Lead Software ConsultantKnoldus
schedule 3 years agoSold Out!
The type system plays an important role in building type-safe applications that reduce runtime exceptions and developer mistakes. This sophisticated system is leveraged by Scala’s most famous functional libraries, such as Scala-Cats and ScalaZ. This feature-rich system allows implementing pure functional programming on the JVM. It is a beast due to its complex syntax, as it prevents developers from exploring its beautiful aspects like partially applying types in Scala. In this talk, we will tame the beast and use its beauty to solve real-life issues faced during coding. Our examples will be based on generics, constraints, type lambdas, and the kind projector plugin.
The following are the learning objectives of this talk:
Practical use cases of the type system using real-life coding.
Implementing custom higher kinded types and handling partially applied types via type lambdas and the kind projector plugin.