If you've ever worked on parallel or multiprocessor software, you've almost certainly encountered bugs owning to race conditions between concurrently-executing components. While race conditions intuitively seem bad, it turns out there are cases in which we can use them to our advantage! In this talk, we'll discuss a number of ways that race conditions are used in improving throughput and reducing latency in high-performance systems, without sacrificing correctness along the way.
We'll begin this exploration with a discussion of how various mutual exclusion primitives like locks are implemented efficiently in modern hardware using benign race conditions. From there, we'll investigate how one can implement non-blocking algorithms and concurrent data structures in a correct and deterministic manner using freely-available open source libraries.
JavaOne 2013 - Clojure for Java DevelopersJan Kronquist
The fact that Clojure is a dialect of Lisp makes it feel completely alien to Java developers, and they miss the opportunity to learn this dynamic and functional programming language for the JVM. Clojure’s focus on immutability makes it very useful for concurrency. This presentation introduces Clojure in a way that feels natural to Java developers. By seeing how well Clojure interoperates with Java, you will learn how to take advantage of this wonderful language and still use all the frameworks and features of the JVM.
Analyzing the Performance Effects of Meltdown + Spectre on Apache Spark Workl...Databricks
Meltdown and Spectre are two security vulnerabilities disclosed in early 2018 that expose systems to cross-VM and cross-process attacks. They were the first of their kind and opened up a new class of exploits that allow one program to scan another program’s memory. The kernel and VM patches released to address these vulnerabilities have shown to degrade the performance of Apache Spark workloads in the cloud by 2-5%.
This talk will dive deep into the exploits and their patches in order to help explain the origin of this decline in performance.
Java Core | Understanding the Disruptor: a Beginner's Guide to Hardcore Concu...JAX London
2011-11-02 | 05:45 PM - 06:35 PM | Victoria
The Disruptor is new open-source concurrency framework, designed as a high performance mechanism for inter-thread messaging. It was developed at LMAX as part of our efforts to build the world's fastest financial exchange. Using the Disruptor as an example, this talk will explain of some of the more detailed and less understood areas of concurrency, such as memory barriers and cache coherency. These concepts are often regarded as scary complex magic only accessible by wizards like Doug Lea and Cliff Click. Our talk will try and demystify them and show that concurrency can be understood by us mere mortal programmers.
JavaOne 2013 - Clojure for Java DevelopersJan Kronquist
The fact that Clojure is a dialect of Lisp makes it feel completely alien to Java developers, and they miss the opportunity to learn this dynamic and functional programming language for the JVM. Clojure’s focus on immutability makes it very useful for concurrency. This presentation introduces Clojure in a way that feels natural to Java developers. By seeing how well Clojure interoperates with Java, you will learn how to take advantage of this wonderful language and still use all the frameworks and features of the JVM.
Analyzing the Performance Effects of Meltdown + Spectre on Apache Spark Workl...Databricks
Meltdown and Spectre are two security vulnerabilities disclosed in early 2018 that expose systems to cross-VM and cross-process attacks. They were the first of their kind and opened up a new class of exploits that allow one program to scan another program’s memory. The kernel and VM patches released to address these vulnerabilities have shown to degrade the performance of Apache Spark workloads in the cloud by 2-5%.
This talk will dive deep into the exploits and their patches in order to help explain the origin of this decline in performance.
Java Core | Understanding the Disruptor: a Beginner's Guide to Hardcore Concu...JAX London
2011-11-02 | 05:45 PM - 06:35 PM | Victoria
The Disruptor is new open-source concurrency framework, designed as a high performance mechanism for inter-thread messaging. It was developed at LMAX as part of our efforts to build the world's fastest financial exchange. Using the Disruptor as an example, this talk will explain of some of the more detailed and less understood areas of concurrency, such as memory barriers and cache coherency. These concepts are often regarded as scary complex magic only accessible by wizards like Doug Lea and Cliff Click. Our talk will try and demystify them and show that concurrency can be understood by us mere mortal programmers.
This webinar by Oleksandr Navka (Lead Software Engineer, Consultant, GlobalLogic) was delivered at Java Community Webinar #1 on August 12, 2020.
Webinar agenda:
- The new structural unit of the program is Java Records
- Updated instanceof statement
- Updated switch operator
More details and presentation: https://www.globallogic.com/ua/about/events/java-community-webinar-1/
EdSketch: Execution-Driven Sketching for JavaLisa Hua
Sketching is a relatively recent approach to program synthesis, which has shown much promise. The key idea in sketching is to allow users to write partial programs that have “holes” and provide test harnesses or reference implementations, and let synthesis tools create program fragments that the holes such that the resulting complete program has the desired functionality. Traditional solutions to the sketching problem perform a translation to SAT and employ CEGIS. While e ective for a range of programs, when applied to real applications, such translation-based approaches have a key limitation: they require either translating all relevant libraries that are invoked directly or indirectly by the given sketch – which can lead to impractical SAT problems – or creating models of those libraries – which can require much manual effort.
is paper introduces execution-driven sketching, a novel approach for synthesis of Java programs using a backtracking search that is commonly employed in so ware model checkers. e key novelty of our work is to introduce effective pruning strategies to effciently explore the actual program behaviors in presence of libraries and to provide a practical solution to sketching small parts of real-world applications, which may use complex constructs of modern languages, such as reflection or native calls. Our tool EdSketch embodies our approach in two forms: a stateful search based on the Java PathFinder model checker; and a stateless search based on re-execution inspired by the VeriSoft model checker. Experimental results show that EdSketch’s performance compares well with the well-known SAT-based Sketch system for a range of small but complex programs, and moreover, that EdSketch can complete some sketches that require handling complex constructs.
This week, Luke Pearson (Polychain Capital) and Joshua Fitzgerald (Anoma) present their work on Plonkup, a protocol that combines Plookup and PLONK into a single, efficient protocol. The protocol relies on a new hash function, called Reinforced Concrete, written by Dmitry Khovratovich. The three of them will present their work together at this week's edition of zkStudyClub!
Slides:
---
To Follow the Zero Knowledge Podcast us at https://www.zeroknowledge.fm
To the listeners of Zero Knowledge Podcast, if you like what we do:
- Follow us on Twitter - @zeroknowledgefm
- Join us on Telegram - https://t.me/joinchat/TORo7aknkYNLHmCM
- Support our Gitcoin Grant - https://gitcoin.co/grants/329/zero-knowledge-podcast-2
- Support us on Patreon - https://www.patreon.com/zeroknowledge
New and delete are a thing of the past, with the new features in C++14 and beyond (such as smart pointers and move semantics) memory management is easier and safer. Learn how to use the new constructs of C++14 and beyond to create, move, and free objects in a safer and more efficient manner.
Next Generation Indexes For Big Data Engineering (ODSC East 2018)Daniel Lemire
Maximizing performance in data engineering is a daunting challenge. We present some of our work on designing faster indexes, with a particular emphasis on compressed indexes. Some of our prior work includes (1) Roaring indexes which are part of multiple big-data systems such as Spark, Hive, Druid, Atlas, Pinot, Kylin, (2) EWAH indexes are part of Git (GitHub) and included in major Linux distributions.
We will present ongoing and future work on how we can process data faster while supporting the diverse systems found in the cloud (with upcoming ARM processors) and under multiple programming languages (e.g., Java, C++, Go, Python). We seek to minimize shared resources (e.g., RAM) while exploiting algorithms designed for the single-instruction-multiple-data (SIMD) instructions available on commodity processors. Our end goal is to process billions of records per second per core.
The talk will be aimed at programmers who want to better understand the performance characteristics of current big-data systems as well as their evolution. The following specific topics will be addressed:
1. The various types of indexes and their performance characteristics and trade-offs: hashing, sorted arrays, bitsets and so forth.
2. Index and table compression techniques: binary packing, patched coding, dictionary coding, frame-of-reference.
A look at the future of JVM languages including Kotlin, Scala, Groovy, and latest Java.
Which language to use ? what are the benefits of higher level abstractions ? and what are the benefits of programming on the JVM ?
This webinar by Oleksandr Navka (Lead Software Engineer, Consultant, GlobalLogic) was delivered at Java Community Webinar #1 on August 12, 2020.
Webinar agenda:
- The new structural unit of the program is Java Records
- Updated instanceof statement
- Updated switch operator
More details and presentation: https://www.globallogic.com/ua/about/events/java-community-webinar-1/
EdSketch: Execution-Driven Sketching for JavaLisa Hua
Sketching is a relatively recent approach to program synthesis, which has shown much promise. The key idea in sketching is to allow users to write partial programs that have “holes” and provide test harnesses or reference implementations, and let synthesis tools create program fragments that the holes such that the resulting complete program has the desired functionality. Traditional solutions to the sketching problem perform a translation to SAT and employ CEGIS. While e ective for a range of programs, when applied to real applications, such translation-based approaches have a key limitation: they require either translating all relevant libraries that are invoked directly or indirectly by the given sketch – which can lead to impractical SAT problems – or creating models of those libraries – which can require much manual effort.
is paper introduces execution-driven sketching, a novel approach for synthesis of Java programs using a backtracking search that is commonly employed in so ware model checkers. e key novelty of our work is to introduce effective pruning strategies to effciently explore the actual program behaviors in presence of libraries and to provide a practical solution to sketching small parts of real-world applications, which may use complex constructs of modern languages, such as reflection or native calls. Our tool EdSketch embodies our approach in two forms: a stateful search based on the Java PathFinder model checker; and a stateless search based on re-execution inspired by the VeriSoft model checker. Experimental results show that EdSketch’s performance compares well with the well-known SAT-based Sketch system for a range of small but complex programs, and moreover, that EdSketch can complete some sketches that require handling complex constructs.
This week, Luke Pearson (Polychain Capital) and Joshua Fitzgerald (Anoma) present their work on Plonkup, a protocol that combines Plookup and PLONK into a single, efficient protocol. The protocol relies on a new hash function, called Reinforced Concrete, written by Dmitry Khovratovich. The three of them will present their work together at this week's edition of zkStudyClub!
Slides:
---
To Follow the Zero Knowledge Podcast us at https://www.zeroknowledge.fm
To the listeners of Zero Knowledge Podcast, if you like what we do:
- Follow us on Twitter - @zeroknowledgefm
- Join us on Telegram - https://t.me/joinchat/TORo7aknkYNLHmCM
- Support our Gitcoin Grant - https://gitcoin.co/grants/329/zero-knowledge-podcast-2
- Support us on Patreon - https://www.patreon.com/zeroknowledge
New and delete are a thing of the past, with the new features in C++14 and beyond (such as smart pointers and move semantics) memory management is easier and safer. Learn how to use the new constructs of C++14 and beyond to create, move, and free objects in a safer and more efficient manner.
Next Generation Indexes For Big Data Engineering (ODSC East 2018)Daniel Lemire
Maximizing performance in data engineering is a daunting challenge. We present some of our work on designing faster indexes, with a particular emphasis on compressed indexes. Some of our prior work includes (1) Roaring indexes which are part of multiple big-data systems such as Spark, Hive, Druid, Atlas, Pinot, Kylin, (2) EWAH indexes are part of Git (GitHub) and included in major Linux distributions.
We will present ongoing and future work on how we can process data faster while supporting the diverse systems found in the cloud (with upcoming ARM processors) and under multiple programming languages (e.g., Java, C++, Go, Python). We seek to minimize shared resources (e.g., RAM) while exploiting algorithms designed for the single-instruction-multiple-data (SIMD) instructions available on commodity processors. Our end goal is to process billions of records per second per core.
The talk will be aimed at programmers who want to better understand the performance characteristics of current big-data systems as well as their evolution. The following specific topics will be addressed:
1. The various types of indexes and their performance characteristics and trade-offs: hashing, sorted arrays, bitsets and so forth.
2. Index and table compression techniques: binary packing, patched coding, dictionary coding, frame-of-reference.
A look at the future of JVM languages including Kotlin, Scala, Groovy, and latest Java.
Which language to use ? what are the benefits of higher level abstractions ? and what are the benefits of programming on the JVM ?
Parallele Suche in grossen Graphen mit Heuristiken und CachesJAVAPRO
Die Suche in grossen Graphen (mehr als 1 Mrd. Knoten) lässt sich auf verschiedene Arten optimieren: Mit Heuristiken, Caches für Teillösungen und Parallelisierung. Mit den ersten beiden Optimierungen erzielt man bei sequentieller Programmierung in vielen Fällen dramatische Verbesserungen. Versucht man durch Parallelität die nächste Stufe der Optimierung, erlebt man oft sein blaues Wunder: Die notwendige Synchronisierung macht den parallelen Algorithmus langsamer als den sequentiellen. Das muss nicht sein. An einem praktischen Beispiel wird gezeigt, wie man alle drei Optimierungen kombinieren kann. Von Dr. Roger, Butenuth.
The State of Lightweight Threads for the JVMVolkan Yazıcı
Thanks to your constantly crashing desktop apps, you know about processes. Microservice flavored web development taught us about threads too. Then came callbacks, shortening lifetime of millions of developers. Do you recall the day you shed tears when Java shipped a Future that you can complete? I know you haven't forgotten how Reactive Streams occupied our agendas with RxJava, Reactor, and infinite stack traces. Now newspapers are yelling about coroutines, fibers, lightweight threads! We poor souls... In this presentation, I aim to give a 2,000ft overview of where do we come from, where are we heading to, and what does all this mean for the Java Virtual Machine, aka, JVM. Are you a Java developer? Thread circus owner? Reactive ninja? Kotlin fan? COBOL enthusiast? Algol pensioner? There is something I will tell you. (Spoiler: I will as well talk about Project
Loom, structured concurrency, and scoped variables.)
This presentation helps discover some of the specific features of Java 8, (in particular, atomics and parallelism) and start using them effectively.
This presentation by Maksym Voronyi (Software Engineer, GlobalLogic) was delivered at Java.io 3.0 conference in Kharkiv on March 24, 2016, and GlobalLogic Mykolaiv Java Conference on June 11, 2016.
Kotlin coroutine - the next step for RxJava developer?Artur Latoszewski
Kotlin is a language that is rapidly gaining popularity, among others thanks to cooperation with Java. On the other hand, RxJava has brought us many solutions to problems related to asynchronous code. If everything is so cool, do we need anything else in the Kotlin world? Is Kotlin Coroutine a competition for RxJava?
Davide Cerbo - Kotlin: forse è la volta buona - Codemotion Milan 2017 Codemotion
Dopo 20 anni Java inizia a sentire il peso degli anni e la sua sintassi non evolve come vorremmo, ma la JVM resta sempre un ambiente affidabile ed è già in produzione presso moltissime aziende. Negli ultimi anni sono usciti molti linguaggi basati sulla JVM, ma non tutti hanno avuto il successo sperato. Kotlin ha conquistato Android e, ora, grazie a una sintassi intuitiva e grandi aziende che lo supportano potrebbe essere molto utilizzato anche nelle applicazioni web. Durante il talk vedremo le basi del linguaggio e come sviluppare una applicazione web pronta ad andare in produzione.
RFC 7540 was ratified over 2 years ago and, today, all major browsers, servers, and CDNs support the next generation of HTTP. Just over a year ago, at Velocity, we discussed the protocol, looked at some real world implications of its deployment and use, and what realistic expectations we should have from its use. Now that adoption is ramped up and the protocol is being regularly used on the Internet, it's a good time to revisit the protocol and its deployment. Has it evolved? Have we learned anything? Are all the features providing the benefits we were expecting? What's next?In this session, we'll review protocol basics and try to answer some of these questions based on real-world use of it. We'll dig into the core features like interaction with TCP, server push, priorities and dependencies, and HPACK. We'll look at these features through the lens of experience and see if good practice patterns have emerged. We'll also review available tools and discuss what protocol enhancements are in the near and not-so-near horizon.
Altitude San Francisco 2018: Preparing for Video Streaming Events at ScaleFastly
CBS Interactive streams some of the largest video streaming events on the planet, including SuperBowl in 2019. This talk will focus on all the work that goes in ahead of time to prepare and plan for game day. From architecture design to capacity reservations to operational visibility and building playbooks we will explore how we build, test and prepare for these large events. We will also explore how some of Fastly's unique features such as MediaShield and VCL are becoming critical to these workflows.
Altitude San Francisco 2018: Building the Souther Hemisphere of the InternetFastly
As a global organization, Fastly carefully selects and deploys POP locations to service the greater audience of the Internet. Fastly currently has 52 global POPs across the Internet, 13 of which are located in the Southern Hemisphere. Another 3 are outside North America, Europe, and Asia. During this talk, VP of Infrastructure Tom Daly will share our experience in building Fastly's network of POPs south of the equator, where, in some cases, the Internet we know here in San Francisco, is much different. Tom will explore the physical datacenter infrastructure, network topology, and network policy that pose of unique challenges when operating in these parts of the world.
Altitude San Francisco 2018: The World Cup StreamFastly
FuboTV’s recent offering of the 2018 FIFA World Cup broke all of our previous records for viewership and put our systems to the test as we delivered all 64 matches live. Coverage for a majority of games was spread out across ~150 regional sports networks, local FOX affiliates, owned and operated regional stations and other local FOX offerings, with a few early matches broadcasted on national channels. Running a successful World Cup required us to pay close attention to our caching strategies, delivery mechanisms, content edge-case handling and more. An event at this scale, spread out over a month, also gave us an excellent test bed to run experiments. We were able to augment our last-mile delivery, test/tweak our solution for CDN decisioning/priority, and even stand up a set of UHD HDR10 feeds to give our users their first glimpse of live OTT UHD offerings. We’ll run through this whole event from a scale and technology perspective and share our takeaways as we prepare for the upcoming NFL season and beyond.
Altitude San Francisco 2018: Scale and Stability at the Edge with 1.4 Billion...Fastly
Braze is a customer engagement platform that delivers more than a billion messaging experiences across push, email, apps and more each day. In this session, Jon Hyman will describe the company's challenges during an inflection point in 2015 when the company reached the limitation of their physical networking equipment, and how Braze has since grown more than 7x on Fastly. Jon will also discuss how Braze uses Fastly's Layer 7 load balancing to improve stability and uptime of its APIs.
Altitude San Francisco 2018: Moving Off the Monolith: A Seamless MigrationFastly
In this talk, Jeff Valeo from Grubhub will talk about how they leveraged Fastly to slowly migrate user traffic from a legacy monolith to a new, service-based architecture. This solution allowed Grubhub to shift millions of users as new functionality was built with zero downtime.
Altitude San Francisco 2018: Bringing TLS to GitHub PagesFastly
Sam Kottler, SRE Engineering Manager at GitHub will dig into how they rearchitected Pages, so that custom domains now support HTTPS, meaning over a million GitHub Pages sites will be served over HTTPS.
Altitude San Francisco 2018: HTTP Invalidation WorkshopFastly
One of the most powerful tools that Fastly offers is worldwide, instant purge. Come learn the ins and outs of how HTTP invalidation works in general and how purge and surrogate keys can be used to improve your site's delivery and get even more value from Fastly.
This talk will also cover the purge blast radius
Surrogate Keys are an amazing way to purge your content from cache, but they can be a bit scary when you aren't sure how many URLs this surrogate key is tied to or what kind of affect this will have on origin. Join the USA Today Network as we explain how we leverage big data tools, Go APIs, New Relic, and Sumo Logic to provide our users a suite of tools for purging content from Fastly. Developers love knowing the blast radius of their surrogate keys, while our engineers love the real-time metrics and notifications we get when developers are hard-purging content.
Altitude San Francisco 2018: How Magento moved to the cloud while maintaining...Fastly
Magento Commerce was first released by a small web development agency over ten years when they saw first-hand what a challenge it was for companies like them to build unique eCommerce sites. They created an open source platform that gives developers the flexibility to create meaningful shopping experiences while building a global community that drives down merchant costs and fosters innovation. Amid the rise of cloud-based software Magento needed to keep pace with more complex merchant needs and heightened shopper expectations. In this session learn how Magento, with the help of Partners like Fastly, evolved into a cloud-based platform without sacrificing their commitment to open software, flexibility, and the community.
Altitude San Francisco 2018: Scaling Ethereum to 10B requests per dayFastly
ConsenSys is a venture production studio building decentralized applications and developer and end-user tools for blockchains. Their Infura platform is a core infrastructure pillar of Ethereum, enabling decentralized applications of all kinds to scale to accommodate their users.
Infura went from 20 million requests a day at the beginning of 2017 to over 10 billion requests today. This staggering 500x increase naturally lead to questions of scale.
In this talk, co-founder Michael Wuehler will discuss the technical challenges encountered while building and scaling the Infura platform, and the infrastructure decisions that led to their adoption of Fastly and other pivotal technologies.
Altitude San Francisco 2018: Authentication at the EdgeFastly
Turning away unwanted traffic close to the source is a common and key use case for edge networks like Fastly, but identity, authentication, and authorization at the edge can go far beyond blocking DDoS. The unique way that you identify your site’s users can probably move to the edge too, allowing you to cut response times in your critical path, offload more origin traffic, and make smarter routing decisions at the edge.
In this talk we’ll cover a number of patterns in use by real Fastly customers. Whether you prefer token authentication, pre-shared keys, OAuth, HTTP auth, JSON web tokens, or a complex paywall, learn how you can potentially make your authentication decisions at the edge.
Altitude San Francisco 2018: Testing with Fastly WorkshopFastly
A crucial step for continuous integration and continuous delivery with Fastly is testing the service configuration to provide confidence in changes. This workshop will cover unit-testing VCL, component testing a service as a black box, systems testing a service end-to-end and stakeholder acceptance testing.
Altitude San Francisco 2018: Fastly Purge Control at the USA TODAY NETWORKFastly
One of the most powerful tools that Fastly offers is worldwide, instant purge. Come learn the ins and outs of how HTTP invalidation works in general and how purge and surrogate keys can be used to improve your site's delivery and get even more value from Fastly.
This talk will also cover the purge blast radius
Surrogate Keys are an amazing way to purge your content from cache, but they can be a bit scary when you aren't sure how many URLs this surrogate key is tied to or what kind of affect this will have on origin. Join the USA Today Network as we explain how we leverage big data tools, Go APIs, New Relic, and Sumo Logic to provide our users a suite of tools for purging content from Fastly. Developers love knowing the blast radius of their surrogate keys, while our engineers love the real-time metrics and notifications we get when developers are hard-purging content.
In this hands-on workshop you will attack a vulnerable web application while defending your own web service behind a Fastly WAF. Attendees will depart understanding how common web application attacks can be exploited as well defended against. They will experience WAF logging and analytics via sumologic to detect attacks realtime. For mitigation you will use a preview version of our newly built WAF rule management UI. We will close off the workshop by deep diving on how our security team analyzed and mitigated some of this summer major vulnerabilities.
Altitude San Francisco 2018: Logging at the Edge Fastly
Fastly delivers more than a million log events per second. Our Real-Time Log Streaming is easy to set up, but there are many features you might not be using to their full extent.
This workshop will cover setting up logging to various endpoints, dealing with structured data, and getting real-time insights into your customers’ behavior.
Altitude San Francisco 2018: Video Workshop DocsFastly
Fastly delivers more than a million log events per second. Our Real-Time Log Streaming is easy to set up, but there are many features you might not be using to their full extent.
This workshop will cover setting up logging to various endpoints, dealing with structured data, and getting real-time insights into your customers’ behavior.
- - - - - - - - - - -
Live streaming and on-demand video can provide a powerful way to connect with customers, but viewers expect seamless pixel-perfect streams without common video delivery inconveniences, such as downtime or lags. This workshop will demonstrate how anyone can deliver live video at scale. We’ll thoroughly explain key video delivery optimizations and more importantly, demonstrate their efficacy using the data collected from both Fastly Log Streaming/Sumo Logic and the Mux quality of experience service.
Altitude San Francisco 2018: Programming the EdgeFastly
Programming the edge
Second floor
Andrew Betts
Principal Developer Advocate, Fastly
Hide abstract
Through our support for running your own code on our edge servers, Fastly's network offers you a platform of unparalleled speed, reliability and efficiency to which you can delegate a surprising amount of logic that has traditionally been in the application layer. In this workshop, you'll implement a series of advanced edge solutions, and learn how to apply these patterns to your own applications to reduce your origin load, dramatically improve performance, and make your applications more secure.
This 7-second Brain Wave Ritual Attracts Money To You.!nirahealhty
Discover the power of a simple 7-second brain wave ritual that can attract wealth and abundance into your life. By tapping into specific brain frequencies, this technique helps you manifest financial success effortlessly. Ready to transform your financial future? Try this powerful ritual and start attracting money today!
1.Wireless Communication System_Wireless communication is a broad term that i...JeyaPerumal1
Wireless communication involves the transmission of information over a distance without the help of wires, cables or any other forms of electrical conductors.
Wireless communication is a broad term that incorporates all procedures and forms of connecting and communicating between two or more devices using a wireless signal through wireless communication technologies and devices.
Features of Wireless Communication
The evolution of wireless technology has brought many advancements with its effective features.
The transmitted distance can be anywhere between a few meters (for example, a television's remote control) and thousands of kilometers (for example, radio communication).
Wireless communication can be used for cellular telephony, wireless access to the internet, wireless home networking, and so on.
# Internet Security: Safeguarding Your Digital World
In the contemporary digital age, the internet is a cornerstone of our daily lives. It connects us to vast amounts of information, provides platforms for communication, enables commerce, and offers endless entertainment. However, with these conveniences come significant security challenges. Internet security is essential to protect our digital identities, sensitive data, and overall online experience. This comprehensive guide explores the multifaceted world of internet security, providing insights into its importance, common threats, and effective strategies to safeguard your digital world.
## Understanding Internet Security
Internet security encompasses the measures and protocols used to protect information, devices, and networks from unauthorized access, attacks, and damage. It involves a wide range of practices designed to safeguard data confidentiality, integrity, and availability. Effective internet security is crucial for individuals, businesses, and governments alike, as cyber threats continue to evolve in complexity and scale.
### Key Components of Internet Security
1. **Confidentiality**: Ensuring that information is accessible only to those authorized to access it.
2. **Integrity**: Protecting information from being altered or tampered with by unauthorized parties.
3. **Availability**: Ensuring that authorized users have reliable access to information and resources when needed.
## Common Internet Security Threats
Cyber threats are numerous and constantly evolving. Understanding these threats is the first step in protecting against them. Some of the most common internet security threats include:
### Malware
Malware, or malicious software, is designed to harm, exploit, or otherwise compromise a device, network, or service. Common types of malware include:
- **Viruses**: Programs that attach themselves to legitimate software and replicate, spreading to other programs and files.
- **Worms**: Standalone malware that replicates itself to spread to other computers.
- **Trojan Horses**: Malicious software disguised as legitimate software.
- **Ransomware**: Malware that encrypts a user's files and demands a ransom for the decryption key.
- **Spyware**: Software that secretly monitors and collects user information.
### Phishing
Phishing is a social engineering attack that aims to steal sensitive information such as usernames, passwords, and credit card details. Attackers often masquerade as trusted entities in email or other communication channels, tricking victims into providing their information.
### Man-in-the-Middle (MitM) Attacks
MitM attacks occur when an attacker intercepts and potentially alters communication between two parties without their knowledge. This can lead to the unauthorized acquisition of sensitive information.
### Denial-of-Service (DoS) and Distributed Denial-of-Service (DDoS) Attacks
APNIC Foundation, presented by Ellisha Heppner at the PNG DNS Forum 2024APNIC
Ellisha Heppner, Grant Management Lead, presented an update on APNIC Foundation to the PNG DNS Forum held from 6 to 10 May, 2024 in Port Moresby, Papua New Guinea.
Bridging the Digital Gap Brad Spiegel Macon, GA Initiative.pptxBrad Spiegel Macon GA
Brad Spiegel Macon GA’s journey exemplifies the profound impact that one individual can have on their community. Through his unwavering dedication to digital inclusion, he’s not only bridging the gap in Macon but also setting an example for others to follow.
Multi-cluster Kubernetes Networking- Patterns, Projects and GuidelinesSanjeev Rampal
Talk presented at Kubernetes Community Day, New York, May 2024.
Technical summary of Multi-Cluster Kubernetes Networking architectures with focus on 4 key topics.
1) Key patterns for Multi-cluster architectures
2) Architectural comparison of several OSS/ CNCF projects to address these patterns
3) Evolution trends for the APIs of these projects
4) Some design recommendations & guidelines for adopting/ deploying these solutions.
26. Allocation Protocol
• An request to allocate is followed by a response
containing an object
• A request to free is followed by a response after the
supplied object has been released
• Allocation requests must not respond with an already-
allocated object
• A free request must not release an already-unallocated
object
31. An Execution History
Time
A(allocate request)
B(allocate request)
A(allocate response)
B(allocate response)
“X happened before Y” =>
“Y may observe X to have occurred”
97. Atomic i
=
i+1;
void
atomic_inc(int
*ptr)
{
int
i,
i_plus_one;
do
{
i
=
*ptr;
i_plus_one
=
i
+
1;
}
while
(!cas(i,
i_plus_one,
ptr));
}
98. void
atomic_inc(int
*ptr)
{
int
i,
i_plus_one;
do
{
i
=
*ptr;
i_plus_one
=
i
+
1;
}
while
(!cas(i,
i_plus_one,
ptr));
}
Atomic i
=
i+1;
99. void
atomic_inc(int
*ptr)
{
int
i,
i_plus_one;
do
{
i
=
*ptr;
i_plus_one
=
i
+
1;
}
while
(!cas(i,
i_plus_one,
ptr));
}
Atomic i
=
i+1;
100. void
atomic_inc(int
*ptr)
{
int
i,
i_plus_one;
do
{
i
=
*ptr;
i_plus_one
=
i
+
1;
}
while
(!cas(i,
i_plus_one,
ptr));
}
Atomic i
=
i+1;
101. void
atomic_inc_mod_32(int
*ptr)
{
int
i,
new_i;
do
{
i
=
*ptr;
new_i
=
i
+
1;
new_i
=
new_i
%
32;
}
while
(!cas(i,
new_i,
ptr));
}
Atomic i
=
(i+1)
%
32;
102. TAS using CAS
void
tas_loop(spinlock
*m)
{
do
{
;
}
while
(!cas(UNLOCKED,
LOCKED,
m));
}
105. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head
));
return
a;
}
slab head
A B …
106. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head
));
return
a;
}
slab head
A B …
107. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head
));
return
a;
}
A B …slab head
108. B …
slab head
A
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head
));
return
a;
}
109. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(
,
,
));
return
a;
}
slab head
a
a b
Cmpr and *
&s->head
A B …
b
a
110. slab head
Cmpr and
Z
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(
,
,
));
return
a;
}
a
a b &s->head
b
a
111. slab head
Z A B
Cmpr and
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(
,
,
));
return
a;
}
a
a b &s->head
b
a
112. slab head
B …
Cmpr and
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(
,
,
));
return
a;
}
a
a b &s->head
b
a
113. void
free(slab
*s,
obj
*o)
{
do
{
obj
*t
=
s-‐>head;
o-‐>next
=
t;
}
while
(!cas(t,
o,
&s-‐>head));
}
B …slab head
114. void
free(slab
*s,
obj
*o)
{
do
{
obj
*t
=
s-‐>head;
o-‐>next
=
t;
}
while
(!cas(t,
o,
&s-‐>head));
}
slab head
A B …
117. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
A B Cslab head
118. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
A B Cslab head
119. A B C
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
slab head
120. A B C
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
slab head
121. A B C
some_object
=
allocate(&shared_slab);
slab head
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
122. A B C
some_object
=
allocate(&shared_slab);
slab head
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
123. B C
A
slab head
some_object
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
124. B C
A
slab head
some_object
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
125. B C
another_obj
=
allocate(&shared_slab);
A
slab head
some_object
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
126. B C
another_obj
=
allocate(&shared_slab);
A
slab head
some_object
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
127. C
A
B
slab head
another_obj
=
allocate(&shared_slab);
some_object
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
128. C
A
B
slab head
another_obj
=
allocate(&shared_slab);
some_object
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
129. B
C
A
slab head
another_obj
=
allocate(&shared_slab);
free(&shared_slab,
some_object);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
130. B
C
A
slab head
another_obj
=
allocate(&shared_slab);
free(&shared_slab,
some_object);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
131. B
A Cslab head
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
free(&shared_slab,
some_object);
132. B
A Cslab head
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
free(&shared_slab,
some_object);
133. B
A Cslab head
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
free(&shared_slab,
some_object);
134. B
A Cslab head
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
free(&shared_slab,
some_object);
135. free(&shared_slab,
some_object);
B
B Cslab head
A
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
136. free(&shared_slab,
some_object);
B
B Cslab head
A
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
137. free(&shared_slab,
some_object);
B
B Cslab head
A
another_obj
=
allocate(&shared_slab);
obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
138. The ABA Problem
“A reference about to be modified by a CAS
changes from a to b and back to a again. As a
result, the CAS succeeds even though its effect on
the data structure has changed and no longer has
the desired effect.” —Herlihy & Shavit, p. 235
139. obj
*allocate(slab
*s)
{
obj
*a,
*b;
do
{
a
=
s-‐>head;
if
(a
==
NULL)
return
NULL;
b
=
a-‐>next;
}
while
(!cas(a,
b,
&s-‐>head));
return
a;
}
A B …slab head
166
140. obj
*allocate(slab
*s)
{
slab
orig,
update;
do
{
orig.gen
=
s.gen;
orig.head
=
s.head;
if
(!orig.head)
return
NULL;
update.gen
=
orig.gen
+
1;
update.head
=
orig.head-‐>next;
}
while
(!dcas(&orig,
&update,
s));
return
orig.head;
}
A B …slab head
166
141. free(slab
*s,
obj
*o)
{
do
{
obj
*t
=
s-‐>head;
o-‐>next
=
t;
}
while
(!cas(t,
o,
&s-‐>head));
}
148.
LDREX
R5,
[m]
;
TAS:
fetch.
.
.
STREXEQ
R5,
LOCKED,
[m]
;
TAS:
.
.
.
and
set
CMPEQ
R5,
#0
;
Did
we
succeed?
LDR
R0,
[R1,
4]
;
a
=
s-‐>head
BEQ
lock_done
;
Yes:
we
are
all
done
BL
snooze
;
No:
Call
snooze()…
B
lock_loop
;
…then
loop
again
lock_done:
B
LR
;
return
;;;;
IN
lock()
lock_loop:
;;;;
IN
allocate()
149.
LDREX
R5,
[m]
;
TAS:
fetch.
.
.
STREXEQ
R5,
LOCKED,
[m]
;
TAS:
.
.
.
and
set
CMPEQ
R5,
#0
;
Did
we
succeed?
LDR
R0,
[R1,
4]
;
a
=
s-‐>head
BEQ
lock_done
;
Yes:
we
are
all
done
BL
snooze
;
No:
Call
snooze()…
B
lock_loop
;
…then
loop
again
lock_done:
B
LR
;
return
;;;;
IN
allocate()
;;;;
IN
lock()
lock_loop:
150. LDR
R0,
[R1,
4]
;
a
=
s-‐>head
BEQ
lock_done
;
Yes:
we
are
all
done
BL
snooze
;
No:
Call
snooze()…
B
lock_loop
;
…then
loop
again
lock_done:
B
LR
;
return
;;;;
IN
allocate()
LDREX
R5,
[m]
;
TAS:
fetch.
.
.
STREXEQ
R5,
LOCKED,
[m]
;
TAS:
.
.
.
and
set
CMPEQ
R5,
#0
;
Did
we
succeed?
;;;;
IN
lock()
lock_loop:
156.
LDREX
R5,
[m]
;
TAS:
fetch.
.
.
STREXEQ
R5,
LOCKED,
[m]
;
TAS:
.
.
.
and
set
CMPEQ
R5,
#0
;
Did
we
succeed?
LDR
R0,
[R1,
4]
;
a
=
s-‐>head
BEQ
lock_done
;
Yes:
we
are
all
done
BL
snooze
;
No:
Call
snooze()…
B
lock_loop
;
…then
loop
again
lock_done:
B
LR
;
return
;;;;
IN
allocate()
;;;;
IN
lock()
lock_loop:
157.
LDREX
R5,
[m]
;
TAS:
fetch.
.
.
STREXEQ
R5,
LOCKED,
[m]
;
TAS:
.
.
.
and
set
CMPEQ
R5,
#0
;
Did
we
succeed?
LDR
R0,
[R1,
4]
;
a
=
s-‐>head
BEQ
lock_done
;
Yes:
we
are
all
done
BL
snooze
;
No:
Call
snooze()…
B
lock_loop
;
…then
loop
again
lock_done:
B
LR
;
return
;;;;
IN
allocate()
;;;;
IN
lock()
lock_loop:
163.
LDREX
R5,
[m]
;
TAS:
fetch.
.
.
STREXEQ
R5,
LOCKED,
[m]
;
TAS:
.
.
.
and
set
CMPEQ
R5,
#0
;
Did
we
succeed?
BEQ
lock_done
;
Yes:
we
are
all
done
BL
snooze
;
No:
Call
snooze()…
B
lock_loop
;
…then
loop
again
lock_done:
DMB
;
Ensure
all
previous
reads
;
have
been
completed
B
LR
;
return
;;;;
IN
unlock()
MOV
R0,
UNLOCKED
DMB
;
Ensure
all
previous
reads
have
;
been
completed
STR
R0,
LR
;;;;
IN
lock()
lock_loop:
178. “lock-free programming is
hard; let’s go ride bikes”?
• high-level performance necessitates an
understanding of low level performance
179. “lock-free programming is
hard; let’s go ride bikes”?
• high-level performance necessitates an
understanding of low level performance
• your computer is a distributed system
180. “lock-free programming is
hard; let’s go ride bikes”?
• high-level performance necessitates an
understanding of low level performance
• your computer is a distributed system
• (optional third answer: it’s real neato)
181.
182.
183.
184.
185.
186.
187. Come see us at the booth!
Nathan Taylor | nathan.dijkstracula.net | @dijkstracula
Thanks
credits, code, and additional material at
https://github.com/dijkstracula/Surge2015/