Learning Computer Architecture
Computer Architecture begins with electronics. As computers are built layer upon layer starting with primitive gates baked into silicon, followed by chips and logic gates, hardware platform including ALU, RAM, cache etc., and so on, so is the study of computer architecture a study of each of these layers of abstraction.
Students of computer architecture usually rely on simulators, often written in Java or similar imperative/object oriented languages, to aid their learning. Here are some examples of such a program:
As an Erlang/functional programming enthusiast studying computer architecture I decided to write my own equivalent tools in Erlang and TypeScript as I went about my learning. I am studying computer architecture and simultaneously writing the required simulators and other tooling in Erlang and TypeScript.
Building such emulators and tools in Erlang and Typescript results in distinctly different architectures. I'll be demoing the simulator I built and talking about lessons learned doing this.
Outline/structure of the Session
A war story of my experience learning computer architecture while simultaneously writing the necessary tools using Erlang. I'll explain how I started, the layers of computer architecture I worked through, how I wrote the required tools, and the lessons I learned in the process.
More inputs into computer architecture, encouragement to use Erlang for tasks not usually considered for the language.
schedule Submitted 8 months ago
People who liked this proposal, also liked:
Manuel Chakravarty - Haskell SpriteKit - a Purely Functional API for a Stateful Animation System and Physics EngineManuel ChakravartyLambda ScientistApplicative & Tweag I/O
schedule 9 months agoSold Out!
Graphics, animation, and games programming in Haskell faces a dilemma. We can either use existing frameworks with their highly imperative APIs (such as OpenGL, Cocos2D, or SpriteKit) or we waste a lot of energy trying to re-engineer those rather complex systems from scratch. Or, maybe, we can escape the dilemma. Instead of a Haskell program directly manipulating the mutable object-graph of existing high-level frameworks, we provide an API for purely functional transformations of a Haskell data structure, together with an adaptation layer that transcribes those transformations into edits of the mutable object-graph.
I this talk, I will explain how I used this approach to architect a Haskell binding to the animation system and physics engine of Apple’s SpriteKit framework. I will discuss both how the binding is structured and how it achieves the translation of Haskell side changes to SpriteKit and vice versa, such that it is sufficiently efficient. Moreover, I will demonstrate by example how to use the Haskell library to implement a simple game.
Tony Morris - Functional Programming in AviationTony Morris
schedule 8 months agoSold Out!
In this talk & demo, we have a look at some of the low-hanging problems in general aviation and how functional programming can be applied to provide significant improvements in efficiency and air safety. The current solutions to problems such as navigation, traffic/terrain collision avoidance and weight/balance calculations will be demonstrated to the audience, mostly for amusement. More seriously, we will have a look at the legacy that has led to the way things are, and how to improve by applying our programming skills.
We will look at:
- how aviation safety is regulated.
- how aeronautical services are provided to flight operators.
- how aeronautical navigation is conducted and regulated.
- how the weight and balance for a flight is conducted.
- the methods by which aircraft and ground coordinate between each other.
We will see:
- some real (and basic) data management problems in aviation, that very obviously threaten safety, then solve them, using programming.
- we will see a live demonstration of aeronautical navigation methods, investigate incident reports where lives were lost as a result, and consider how our programming skills can yield improvements, possibly even save lives.
- we will conduct a real weight&balance calculation for a flight, then once hilarity inevitably ensues, we will look at the problems that arise by this method, then solve them using data structures and functional programming. Some
of these practical problems are obvious, even to a non-aviator, and the predictable incident reports are the end result.
- finally, we will have a look at a live demonstration of a software defined radio (SDR), receiving ADS-B transmissions from aircraft (live), an AHRS implementation and GNSS receiver using off-the-shelf, low-cost parts. We will look at why these instruments are helpful to aircraft pilots and interact with that device using the Haskell programming language.
Chaitanya Chalasani - High Performance Data Mart using Event PlotsChaitanya ChalasaniSenior Software ArchitectNetstratum Technologies Pvt Ltd
schedule 7 months agoSold Out!
Reporting data for finite state machine transactions like calls require exhaustive data mining into 10s and 100s of parameters for 1000s of calls per hour. These postmortems require heavy processing and can demand millions of maps per reduction. The presentation is a case study and demonstration of near-realtime asynchronous event processing based plotting of events and states of FSMs. Thus creating semi-cooked event plots delivering lightening fast reports with extensive customizability.
Roger Hui - Tests, Derivations, ProofsRoger HuiprogrammerDyalog Ltd.
schedule 9 months agoSold Out!
John Hughes and Mary Sheeran in Why Functional Programming Matters  list “algebra as a litmus test” as one of the four salient features of functional programming, and Ken Iverson in Notation as a Tool of Thought  lists “amenability to formal proof” as one of the five important characteristics of notation. Using the language APL, we prove the correctness of some programs, derive simplifications, and illustrate design validation and program test techniques for functional programs.
 Hughes, John, and Mary Sheeran, Why Functional Programming Matters, Code Mesh, London, 2015-11-02 to -04.
 Iverson, Kenneth E., Notation as a Tool of Thought, Communications of the ACM, volume 23, number 8, 1980-08.
Ravi Mohan - Predator: A Framework for Developing Programmatic Players for Complex Board GamesRavi MohanCEOAxiomChoice
schedule 9 months agoSold Out!
Summary: An Experience Report on How a very time constrained Haskeller learned Erlang and PureScript "in small pieces" to create programmatic opponents aka 'bots' for complex boardgames
Every experience report tells a story - the story of a project, unvarnished and without artifice, programmer to programmer, out of the sight and hearing of the manager folks, often involving one or more of comedy, tragedy, farce etc. This report is no exception.
I have a fulltime 'dayjob' and my standard 'language toolkit' is Haskell + C + Lua. My co-founder is a bit of an Erlang maniac, and challenged me to learn Erlang and actually building something in it and *then* go on about the superiority of Haskell.
This is the story of my response to the challenge and how I learned and coded Erlang/Elixir in very small chunks of time (about 10 - 20 )minutes a day max) and attacked an interesting problem. This severe time constraint (and lack of any previous knowledge of Erlang) shaped the nature of the (still evolving) system.
The number of boardgames that you can whip out at a gathering and expect people to want play is very small.. Monopoly, Snakes and Ladders, and maybe, if you are *very* lucky, Settlers of Catan. And that's about it.
Getting people to play these games is relatively easy.
However the world of boardgames is *much* wider.
There are literally tens of thousands of boardgames that simulate everything from very abstract geometry puzzles to ones that simulate complex economies and political situations.
Some of the latter are used in very unexpected ways, e.g to train spies and military officers.
Here is an example of an interesting game.
A Distant Plain (by GMT Games) is a boardgame for 4 players that put them in the roles of the US military forces, the Afghan government, the Taliban, and Warlords/drug dealers, all competing for power in Afghanistan.
Here is another
The War of the Ring, a game for 2 players.
"In War of the Ring, one player takes control of the Free Peoples (FP), the other player controls Shadow Armies (SA). Initially, the Free People Nations are reluctant to take arms against Sauron, so they must be attacked by Sauron or persuaded by Gandalf or other Companions, before they start to fight properly ...."
And one more
"The battle of Sekigahara, fought in 1600 at a crossroads in Japan, unified that nation under the Tokugawa family for more than 250 years.
Sekigahara allows you to re-contest that war as Ishida Mitsunari, defender of a child heir, or Tokugawa Ieyasu, Japan's most powerful daimyo (feudal lord)."
What these games have in common
1. They are wonderful games, immersing you into their respective worlds.
2. They have (relative to Snakes and Ladders or Monopoly) complex rulesets, which take effort and time to master.
3. They are rarely played in India.
4. Even when people own them, opponents are almost impossible to find and schedule.
Which means that if you own these games and live in India, getting to actually play these games is close to impossible.
Which is a problem.
The (incomplete, but ongoing) solution
Being a programmer, I solve this problem by writing programmatic opponents (aka 'bots') to take the place of other players. This involves all kinds of interesting sub problems - game representation, logic processing for rules, building AI 'smarts' for your opponents, gui and event handling etc.
Since I am doing this in my non existent spare time, and this being a response to an Erlang user's challenge, I learned (am sill learning) Erlang and Elixir (and some minimal PureScript), and built ( am still building) the system at the same time..
This talk is about the many challenges I faced in building automated game players (and extracting common frameworks/libraries) from them, while simultaneously learning two FP languages.
Since this is an experience report, it is basically a highly subjective list of lessons learned, victories *and defeats*, what worked *and more importantly what didn't work*.
If you can't use FP at work, but are considering doing so on a personal project, or want to learn how to get going on an FP learning effort, you might benefit from my experience - both successes and failures. I also talk about how to go about learning Erlang/Elixir in the shortest possible time.
Cameron Price - Making it Fast: The Power of BenchmarkingCameron PriceCTOTRX.tv
schedule 7 months agoSold Out!
There's an old expression, usually attributed to Kent Beck, that we should "Make it work, make it right, make it fast", in that order. This talk is going to focus on making it fast.
Not long ago, I was working on a little problem in Elixir that involved a two dimensional array. Now, Elixir doesn't really have arrays, it has lists, maps, tuples, and binaries, so the one thing we can be sure about when implementing a 2-d array is that we're going to be simulating it using something else. What I discovered was surprising, and served as an important lesson about actually benchmarking things.
In this talk, we'll discuss the importance of benchmarking, demonstrate some tools that make benchmarking in Elixir very simple, and show you some surprising results about which approaches are faster in this language.
Shantanu Kumar - A functional workflow for bootstrapping applicationsShantanu KumarPrincipal EngineerConcur
schedule 8 months agoSold Out!
Application configuration and initialization are tangential to delivering business value, yet we frequently get bogged down by their incidental complexity. They crosscut various (Dev/QA/Prod etc.) environments and impact the workflow in subtle, disparate ways. In this session, I will discuss the experience of tackling this beast for several projects in a large team using an elegant functional programming approach. The approach was turned into a data-driven Clojure framework for applications to use. This success story is over two years old in production and it scales from a junior developer looking to learn the ropes to experienced folks focusing on advanced use cases. I will discuss the fundamentals of this approach, how it is used in production, in QA, and in development. I will also share the REPL-enabled development workflow and how it facilitates automated unit and integration testing.