This is a talk given at Clojure Conj 2014 in Washington DC. The title was Paradigms of core.async and it was given by Julian Gamble.
The code and demos are available here: https://github.com/juliangamble/clojure-conj-2014-paradigms-of-core-async
Applying the paradigms of core.async in Clojure and ClojureScriptJulian Gamble
In this workshop you’ll see a Clojure program that visually demonstrates Clojure’s concurrency semantics and then see how to solve the same underlying concurrency problems using core.async. You’ll see the mapping between programming paradigms you already know and core.async concepts. You’ll apply this in the browser with ClojureScript.
This is a presentation for International Lisp Conference 2012 which was held in Kyoto, Japan.
Clack is a web application environment for Common Lisp to make your web applications be portable and reusable by abstracting HTTP into a simple API.
In this paper, I describe what are problems in web development and how Clack solves them.
Automating Your Daily Tasks with Scripting - RubyConf 2015 TaiwanAdler Hsieh
This talk aims to go through basic scripting skills in Ruby. Participants will have a better understanding in managing their daily tasks with scripting. For example, we can setup automated scripts to delete old files on a daily basis instead of doing it manually. These can be done with Bash, Perl and many other scripting languages, but among of which Ruby is better known for its readability. It is easier to write, maintain, and reuse. It saves some time on system management and allows us to put more focus on the projects.
Ruby developers need to stop using EventMachine. It's the wrong direction.
Lost in the "Threads vs Event Driven vs Process Spawning" debate is that you can combine them! Learn how Celluloid is improving thread programming by abstracting them using a higher level framework called Celluloid, how you can use Celluloid::IO to throw a reactor pattern into a thread. Using this approach, you can take advantage of threading and use all CPU power on a machine with JRuby or Rubinius. I also discuss the future of distributed objects and computing, and where I think things are going.
Applying the paradigms of core.async in Clojure and ClojureScriptJulian Gamble
In this workshop you’ll see a Clojure program that visually demonstrates Clojure’s concurrency semantics and then see how to solve the same underlying concurrency problems using core.async. You’ll see the mapping between programming paradigms you already know and core.async concepts. You’ll apply this in the browser with ClojureScript.
This is a presentation for International Lisp Conference 2012 which was held in Kyoto, Japan.
Clack is a web application environment for Common Lisp to make your web applications be portable and reusable by abstracting HTTP into a simple API.
In this paper, I describe what are problems in web development and how Clack solves them.
Automating Your Daily Tasks with Scripting - RubyConf 2015 TaiwanAdler Hsieh
This talk aims to go through basic scripting skills in Ruby. Participants will have a better understanding in managing their daily tasks with scripting. For example, we can setup automated scripts to delete old files on a daily basis instead of doing it manually. These can be done with Bash, Perl and many other scripting languages, but among of which Ruby is better known for its readability. It is easier to write, maintain, and reuse. It saves some time on system management and allows us to put more focus on the projects.
Ruby developers need to stop using EventMachine. It's the wrong direction.
Lost in the "Threads vs Event Driven vs Process Spawning" debate is that you can combine them! Learn how Celluloid is improving thread programming by abstracting them using a higher level framework called Celluloid, how you can use Celluloid::IO to throw a reactor pattern into a thread. Using this approach, you can take advantage of threading and use all CPU power on a machine with JRuby or Rubinius. I also discuss the future of distributed objects and computing, and where I think things are going.
Developing high-performance network servers in LispVladimir Sedach
Overview of current high-performance Common Lisp web servers and implementation techniques, and description of a new hybrid approach to asynchronous I/O based on separate racing accept() and epoll() thread pools.
Introduces Ansible as DevOps favorite choice for Configuration Management and Server Provisioning. Enables audience to get started with using Ansible. Developed in Python which only needs YAML syntax knowledge to automate using this tool.
● Fundamentals
● Key Components
● Best practices
● Spring Boot REST API Deployment
● CI with Ansible
● Ansible for AWS
● Provisioning a Docker Host
● Docker&Ansible
https://github.com/maaydin/ansible-tutorial
Ansible 101 - Presentation at Ansible STL MeetupJeff Geerling
Jeff Geerling, author of Ansible for DevOps, demonstrates basic Ansible usage on the Dramble, a cluster of six Raspberry Pi 2 computers.
This presentation was delivered on July 8, 2015, at the Ansible St. Louis meetup, at Riot Games in Clayton, MO.
Highly available Drupal on a Raspberry Pi clusterJeff Geerling
Question: Can you run a Fortune 500 Drupal 8 website from your basement, on a cluster of Raspberry Pi computers?
Answer: See this presentation to find out! Jeff Geerling is the author of Ansible for DevOps and a Technical Architect at Acquia, who has worked on many large and small scale Drupal websites.
Back to the future: Isomorphic javascript applicationsLuciano Colosio
Remember when we use to “render” websites directly from the backend?Single page applications are cool and catchy, but some times they fall short, for example, when hit by a search engine, and that’s when you start turning to isomorphic javascript applications.in this talk I share our experience gained on the field while turning our frontends form angular SPAs to isomorphic vanillaJS javascript apps with node a a thin active layer on the client side, taking the best form famous frameworks such as angular and react, and making our own mix.
Rainbows, Unicorns, and other Fairy Tales in the Land of Serverless DreamsJosh Carlisle
When done correctly Serverless offers fantastic potential but can also lead to spectacular failure when critical concepts are overlooked. With over a dozen Serverless implementations on Azure Functions over the last couple years, I’ve learned some lessons the hard way. In this talk, I will be sharing a few of the most impactful hard-earned lessons and how I was able to overcome them. I’ll be touching on topics ranging from considerations using traditional relational databases, managing service and data connections to managing complexity and increasing observability. The talk is done in the context of Azure Functions but whose concepts apply equally to all Serverless Platforms.
Developing high-performance network servers in LispVladimir Sedach
Overview of current high-performance Common Lisp web servers and implementation techniques, and description of a new hybrid approach to asynchronous I/O based on separate racing accept() and epoll() thread pools.
Introduces Ansible as DevOps favorite choice for Configuration Management and Server Provisioning. Enables audience to get started with using Ansible. Developed in Python which only needs YAML syntax knowledge to automate using this tool.
● Fundamentals
● Key Components
● Best practices
● Spring Boot REST API Deployment
● CI with Ansible
● Ansible for AWS
● Provisioning a Docker Host
● Docker&Ansible
https://github.com/maaydin/ansible-tutorial
Ansible 101 - Presentation at Ansible STL MeetupJeff Geerling
Jeff Geerling, author of Ansible for DevOps, demonstrates basic Ansible usage on the Dramble, a cluster of six Raspberry Pi 2 computers.
This presentation was delivered on July 8, 2015, at the Ansible St. Louis meetup, at Riot Games in Clayton, MO.
Highly available Drupal on a Raspberry Pi clusterJeff Geerling
Question: Can you run a Fortune 500 Drupal 8 website from your basement, on a cluster of Raspberry Pi computers?
Answer: See this presentation to find out! Jeff Geerling is the author of Ansible for DevOps and a Technical Architect at Acquia, who has worked on many large and small scale Drupal websites.
Back to the future: Isomorphic javascript applicationsLuciano Colosio
Remember when we use to “render” websites directly from the backend?Single page applications are cool and catchy, but some times they fall short, for example, when hit by a search engine, and that’s when you start turning to isomorphic javascript applications.in this talk I share our experience gained on the field while turning our frontends form angular SPAs to isomorphic vanillaJS javascript apps with node a a thin active layer on the client side, taking the best form famous frameworks such as angular and react, and making our own mix.
Rainbows, Unicorns, and other Fairy Tales in the Land of Serverless DreamsJosh Carlisle
When done correctly Serverless offers fantastic potential but can also lead to spectacular failure when critical concepts are overlooked. With over a dozen Serverless implementations on Azure Functions over the last couple years, I’ve learned some lessons the hard way. In this talk, I will be sharing a few of the most impactful hard-earned lessons and how I was able to overcome them. I’ll be touching on topics ranging from considerations using traditional relational databases, managing service and data connections to managing complexity and increasing observability. The talk is done in the context of Azure Functions but whose concepts apply equally to all Serverless Platforms.
A chronicle of my attempt to create a real time web app using pure clojure at every layer of the stack, from the client to the styles to the web server
This is an interactive PowerPoint presentation I made for my seminar at my workplace. It talks and illustrates how the JavaScript engine works when executing code. It also contains a step-by-step animation which demonstrates the usage of the JavaScript event loop.
Feel free to use and refer content. Copyrights reserved.
Being able to rapidly iterate on, build and test your code is key to being a productive developer. Without local automation, working with the numerous platforms and technologies in your stack can become very frustrating.
In this on-demand webinar, Ben Bromhead CTO of Instaclustr explores best practices to easily integrate Apache Cassandra into your development workflow, so you spend more time writing good code and less time fighting your environment.
Being able to rapidly iterate on, build, and test your code is key to being a productive developer. Without local automation, working with the numerous platforms and technologies in your stack can become very frustrating. In this webinar, Ben Bromhead CTO of Instaclustr will explore best practices to easily integrate Apache CassandraTM into your development workflow, so you spend more time writing good code and less time fighting your environment.
My talk from Dockercon EU in Amsterdam, Dec 2014. Original abstract:
The ModCloth Platform team has been building a Docker-based continuous delivery pipeline. This presentation discusses that project and how we build containers at ModCloth. The topics include what goes into our containers; how to optimize builds to use the Docker build cache effectively; useful development workflows (including using fig); and the key decision to treat containers as processes instead of mini-vms. This presentation will also discuss (and demo!) the workflow we’ve adopted for building containers and how we’ve integrated container builds with our CI.
Amazon Elastic Kubernetes Service (EKS)는 표준 Kubernetes 환경에서 실행되는 어플리케이션과 완벽히 호환됩니다. AWS상에서 Kubernetes 클러스터를 생성하고, 컨테이너 어플리케이션을 배포, 관리, 확장 및 로깅, 모니터링에 대한 실습과 함께, 최근 릴리즈된 AWS IAM 권한을 Pod에 할당하는 방법 등을 Amazon EKS에서 구현하는 과정을 진행합니다.
The Tale of a Docker-based Continuous Delivery Pipeline by Rafe Colton (ModCl...Docker, Inc.
The ModCloth Platform team has been building a Docker-based continuous delivery pipeline. This presentation discusses that project and how we build containers at ModCloth. The topics include what goes into our containers; how to optimize builds to use the Docker build cache effectively; useful development workflows (including using fig); and the key decision to treat containers as processes instead of mini-vms. This presentation will also discuss (and demo!) the workflow we’ve adopted for building containers and how we’ve integrated container builds with our CI.
Writing concurrent program is hard; maintaining concurrent program even is a nightmare. Actually, a pattern which helps us to write good concurrent code is available, that is, using “channels” to communicate.
This talk will share the channel concept with common libraries, like threading and multiprocessing, to make concurrent code elegant.
It's the talk at PyCon TW 2017 [1] and PyCon APAC/MY 2017 [2].
[1]: https://tw.pycon.org/2017
[2]: https://pycon.my/pycon-apac-2017-program-schedule/
"WTF is Twisted? (or; owl amongst the ponies)" is a talk that introduces the Twisted asynchronous programming framework, how it works, and what uses it.
Devops core principles
CI/CD basics
CI/CD with asp.net core webapi and Angular app
Iac Why and What?
Demo using Azure and Azure Devops
Docker why and what ?
Demo using Azure and Azure Devops
Kubernetes why and what?
Demo using Azure and Azure Devops
With more businesses moving to cloud-based solutions everyday, we must re-think the strategies used to deploy Perl applications and related libraries, given the volatile aspects of the cloud and its constraints.
In this talk I go over the challenges posed by virtualised environments, and consider several solutions to them. The use cases are all related to Amazon's EC2, but will easily be adapted for GoGrid, Mosso, and others.
Similar to Clojure Conj 2014 - Paradigms of core.async - Julian Gamble (20)
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
The Metaverse and AI: how can decision-makers harness the Metaverse for their...Jen Stirrup
The Metaverse is popularized in science fiction, and now it is becoming closer to being a part of our daily lives through the use of social media and shopping companies. How can businesses survive in a world where Artificial Intelligence is becoming the present as well as the future of technology, and how does the Metaverse fit into business strategy when futurist ideas are developing into reality at accelerated rates? How do we do this when our data isn't up to scratch? How can we move towards success with our data so we are set up for the Metaverse when it arrives?
How can you help your company evolve, adapt, and succeed using Artificial Intelligence and the Metaverse to stay ahead of the competition? What are the potential issues, complications, and benefits that these technologies could bring to us and our organizations? In this session, Jen Stirrup will explain how to start thinking about these technologies as an organisation.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
6. Core.async is about:
• queues in your application
• making your application simpler to reason
about
7. Benefits
In this talk you will gain an understanding of:
• go blocks and how they do concurrency
• core.async queues
8. Benefits
In this talk you will gain an understanding of:
• go blocks and how they do concurrency
• core.async queues
• go block timers
• alts! macro and how it enables reading multiple queues
9. Benefits
In this talk you will gain an understanding of:
• go blocks and how they do concurrency
• core.async queues
• go block timers
• alts! functions and how it enables reading multiple queues
• how core.async processes work in ClojureScript
• the visual impacts of how the core.async function enables
simple ‘process-level’ pauses
• how to use core.async to separate out the calculation and
display parts of your code
10. Benefits
In this talk you will gain an understanding of:
• converting a Clojure code-base to ClojureScript
• some tips for optimising ClojureScript
12. What is core.async?
• A set of primitives for creating, reading and
writing to queues
• A code walking macro that splices go blocks
into state machines
13. What is core.async?
• A set of primitives for creating, reading and
writing to queues
• A code walking macro that splices go blocks
into state machines
• A mechanism for asynchronous computation
• A library in both Clojure and ClojureScript
14. What does core.async say about
Clojure?
• core.async is implemented using a sophisticated Lisp
macro - something only possible in a functional
language
• in non-functional languages like Go and C# - CSP is
achieved by compiler-extensions - whereas in a
functional language like Clojure - this functionality
comes as a mere library
15. What is CSP?
• Communicating Sequential Processes
• Comes out of process calculi – an attempt in the
1960’s and 1970’s to optimise computer usage
through specialised algebra.
16. What is CSP?
• Communicating Sequential Processes
• Comes out of process calculi – an attempt in the
1960’s and 1970’s to optimise computer usage
through specialised algebra.
• Based on message passing via
channels
• Subject of 1978 Book by C.A.R. Hoare
33. Tim Baldridge 10K
processes
make-‐scene
function
make-‐cell
function
10K
go
block
1. Set
colour
2. Paint
canvas
cell
3. Pause
for
random
interval
4. Loop
45. swanodette 10K processes
[go
block]
let
block
[idx
v] [idx
v]
[go
block]
render-‐loop ‘render’ ‘queue’ render!
core.async
channel parameter
passed
in
during
function
call
46. swanodette 10K processes
[go
block]
let
block
[idx
v] [idx
v]
[go
block]
render-‐loop ‘render’ ‘queue’ render!
core.async
channel parameter
passed
in
during
function
call
No
more
than
1024
pending
puts
are
allowed
on
a
single
channel.
57. Parallelism is not
Concurrency
Imagine streams of execution in your program
58. Parallelism is not
Concurrency
Imagine streams of execution in your program
59. Parallelism is not
Concurrency
Imagine streams of execution in your program
60. Parallelism
1. For core.async "use it where ever you'd use a queue"
2. In the Tim Baldridge 10K processes example above - it is not explicitly using a
queue
(<! (timeout (rand-int 1000)))))))
61. Parallelism
1. For core.async "use it where ever you'd use a queue"
2. In the Tim Baldridge 10K processes example above - it is not explicitly using a
queue
(<! (timeout (rand-int 1000)))))))
3. But in the same example - it is implicitly using the queue of the core.async
process scheduler - so you're still using a queue.
4. Go blocks are the lightweight equivalent of 'heavyweight' threads
62. Parallelism
1. For core.async "use it where ever you'd use a queue"
2. In the Tim Baldridge 10K processes example above - it is not explicitly using a
queue
(<! (timeout (rand-int 1000)))))))
3. But in the same example - it is implicitly using the queue of the core.async
process scheduler - so you're still using a queue.
4. Go blocks are the lightweight equivalent of 'heavyweight' threads
5. Heavyweight threads implicitly listen to the queue of the OS 'ready queue'
6. You're already implicitly using queues whenever you use threads.
64. Quick recap
• core.async is all about queues
• queues can used in your application for:
• parallelism
• separating the calculation from the display
logic
• event handling
67. Rich Hickey original ants
demo
-‐main
function
send-‐off send-‐off send-‐off
animation
agent
ant
behaviour
agent
evaporation
agent
world
symbol
(vector
of
vectors)
73. Converting to ClojureScript
Missing functions in ClojureScript:
• defstruct - replace with a map
• alter - replace with swap!
74. Converting to ClojureScript
Missing functions in ClojureScript:
• defstruct - replace with a map
• alter - replace with swap!
• sync
• dosync
• agent
75. ants cljs no async
animate
function
requestAnimationFrame
single
call single
call single
send-‐off-‐
animation
function
behave-‐ants
function
(callback)
evaporate
function
world
symbol
(vector
of
vectors)
call
84. Using optimisations from David
Nolen’s chambered example
• Macros for creating arrays and for-loops
• Underlying assumptions:
• cljs data structures are not yet fully performant -
so consider replacing with arrays for speed
• The cljs compiler does not yet fully optimise
higher order functions - the most efficient
looping construct will be a for-loop macro that
uses the loop function
89. Back to The Italian Job
• Who or what was the hero of the story?
90. Summary
• core.async is about using queues
• core.async is about making your application simpler to reason about
91. Summary
• core.async is about using queues
• core.async is about making your application simpler to reason about
• classic applications are: user interface events, presentation loops,
parallelism in non-parallel environments
• you can consider a multithreaded application a queue listener even if
it doesn’t appear to use queues
92. Summary
• core.async is about using queues
• core.async is about making your application simpler to reason about
• classic applications are: user interface events, presentation loops,
parallelism in non-parallel environments
• you can consider a multithreaded application a queue listener even if
it doesn’t appear to use queues
• in porting an application from Clojure to ClojureScript you have to
rethink your concurrency
• There are lots of optimisations available to make ClojureScript
applications run faster
• core.async is not a magic sauce you can sprinkle everywhere - know
when to use it
93. Questions?
Clojure
Conj
Nov
2014
Julian
Gamble
@juliansgamble
github.com/juliangamble/clojure-‐conj-‐2014-‐paradigms-‐of-‐core-‐async