(Video of these slides here http://fsharpforfunandprofit.com/rop)
(My response to "this is just Either" here: http://fsharpforfunandprofit.com/rop/#monads)
Many examples in functional programming assume that you are always on the "happy path". But to create a robust real world application you must deal with validation, logging, network and service errors, and other annoyances.
So, how do you handle all this in a clean functional way? This talk will provide a brief introduction to this topic, using a fun and easy-to-understand railway analogy.
The lazy programmer's guide to writing thousands of testsScott Wlaschin
We are all familiar with example-based testing, as typified by TDD and BDD, where each test is hand-crafted.
But there's another approach to writing tests. In the "property-based testing" approach, a single test is run hundreds of times with randomly generated inputs. Property-based testing is a great way to find edge cases, and also helps you to understand and document the behavior of your code under all conditions.
This talk will introduce property-based testing, show you how it works, and demonstrate why you should consider adding this powerful technique to your toolbelt.
Functional Programming Patterns (NDC London 2014)Scott Wlaschin
(video of these slides available here http://fsharpforfunandprofit.com/fppatterns/)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID.
The functional programming community has design patterns and principles as well.
This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.
Video and more content at fsharpforfunandprofit.com/pbt
"The lazy programmer's guide to writing 1000's of tests: An introduction to property based testing"
We are all familiar with example-based testing, as typified by TDD and BDD. Property-based testing takes a very different approach, where a single test is run hundreds of times with randomly generated inputs.
Property-based testing is a great way to find edge cases, and also helps you to understand and document the behaviour of your code under all conditions.
This talk will introduce property-based testing and show how it works, and why you should consider adding it to your arsenal of testing tools.
(video of these slides available here http://fsharpforfunandprofit.com/fppatterns/)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID.
The functional programming community has design patterns and principles as well.
This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.
Composition is a fundamental principle of functional programming, but how is it different from an object-oriented approach, and how do you use it in practice?
In this talk for beginners, we'll start by going over the basic concepts of functional programming, and then look at some different ways that composition can be used to build large things from small things.
After that, we'll see how composition is used in practice, beginning with a simple FizzBuzz example, and ending with a complete (object-free!) web application.
(Video of these slides here http://fsharpforfunandprofit.com/rop)
(My response to "this is just Either" here: http://fsharpforfunandprofit.com/rop/#monads)
Many examples in functional programming assume that you are always on the "happy path". But to create a robust real world application you must deal with validation, logging, network and service errors, and other annoyances.
So, how do you handle all this in a clean functional way? This talk will provide a brief introduction to this topic, using a fun and easy-to-understand railway analogy.
The lazy programmer's guide to writing thousands of testsScott Wlaschin
We are all familiar with example-based testing, as typified by TDD and BDD, where each test is hand-crafted.
But there's another approach to writing tests. In the "property-based testing" approach, a single test is run hundreds of times with randomly generated inputs. Property-based testing is a great way to find edge cases, and also helps you to understand and document the behavior of your code under all conditions.
This talk will introduce property-based testing, show you how it works, and demonstrate why you should consider adding this powerful technique to your toolbelt.
Functional Programming Patterns (NDC London 2014)Scott Wlaschin
(video of these slides available here http://fsharpforfunandprofit.com/fppatterns/)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID.
The functional programming community has design patterns and principles as well.
This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.
Video and more content at fsharpforfunandprofit.com/pbt
"The lazy programmer's guide to writing 1000's of tests: An introduction to property based testing"
We are all familiar with example-based testing, as typified by TDD and BDD. Property-based testing takes a very different approach, where a single test is run hundreds of times with randomly generated inputs.
Property-based testing is a great way to find edge cases, and also helps you to understand and document the behaviour of your code under all conditions.
This talk will introduce property-based testing and show how it works, and why you should consider adding it to your arsenal of testing tools.
(video of these slides available here http://fsharpforfunandprofit.com/fppatterns/)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID.
The functional programming community has design patterns and principles as well.
This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.
Composition is a fundamental principle of functional programming, but how is it different from an object-oriented approach, and how do you use it in practice?
In this talk for beginners, we'll start by going over the basic concepts of functional programming, and then look at some different ways that composition can be used to build large things from small things.
After that, we'll see how composition is used in practice, beginning with a simple FizzBuzz example, and ending with a complete (object-free!) web application.
Monoids, Store, and Dependency Injection - Abstractions for Spark Streaming JobsRyan Weald
Talk I gave at a Spark Meetup on 01/16/2014
Abstract:
One of the most difficult aspects of deploying spark streaming as part of your technology stack is maintaining all the job associated with stream processing jobs. In this talk I will discuss the the tools and techniques that Sharethrough has found most useful for maintaining a large number of spark streaming jobs. We will look in detail at the way Monoids and Twitter's Algebrid library can be used to create generic aggregations. As well as the way we can create generic interfaces for writing the results of streaming jobs to multiple data stores. Finally we will look at the way dependency injection can be used to tie all the pieces together, enabling raping development of new streaming jobs.
(video and more at http://fsharpforfunandprofit.com/fppatterns)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID. The functional programming community has design patterns and principles as well. This talk will provide an overview of some of these patterns (such as currying, monads), and present some demonstrations of FP design in practice. We'll also look at some of the ways you can use these patterns as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
Workshop slides from the Alt.Net Seattle 2011 workshop. Presented by Wes Dyer and Ryan Riley. Get the slides and the workshop code at http://rxworkshop.codeplex.com/
(Video and code at https://fsharpforfunandprofit.com/pipeline/)
Passing data through a pipeline of transformations is an alternative approach to classic OOP. The LINQ methods in .NET are designed around this, but the pipeline approach can be used for so much more than manipulating collections.
In this talk, I'll look at pipeline-oriented programming and how it relates to functional programming, the open-closed principle, unit testing, the onion architecture, and more. I'll finish up by showing how you can build a complete web app using only this approach.
Types of C++ functions:
Standard functions
User-defined functions
C++ function structure
Function signature
Function body
Declaring and Implementing C++ functions
Let's make a contract: the art of designing a Java APIMario Fusco
An API is what developers use to achieve some task. More precisely it establishes a contract between them and the designers of the software exposing its services through that API. In this sense we're all API designers: our software doesn't work in isolation, but becomes useful only when it interacts with other software written by other developers. When writing software we're not only consumers, but also providers of one or more API and that's why every developer should know the features of a good API. During this presentation we will go through real-world examples, also taken from the standard Java API, of good and bad API and comment them in order to show the dos and don'ts of API design. More in general we will discuss the characteristics of an easy and pleasant to use API, like consistency, discoverability and understandability, together with some basic concepts like the principle of least astonishment, and find out how to achieve them.
Slides from a brief presentation about the 'docase' notation that I did at Haskell Hackathon in Cambridge. The notation makes it easier to work with monads that have some additional operations (such as Par monad or Parsers).
(Video available at http://fsharpforfunandprofit.com/monadster/)
You've got a pile of assorted functions lying around. Each one is useful and reliable, but they just don't fit together properly. How can you assemble them into a complete system that can stand on its own two feet and terrorize the local villagers?
In this session, I'll show how functional programming can transform all sorts of existing code into shapes that are plug-compatible and which can be bolted together effortlessly.
SAFETY NOTE: The techniques demonstrated are perfectly harmless and can even be used at your workplace -- no lightning bolts required.
A slideshow presentation by Doug Albers all about GreatLife KC, and the perks and amenities that come along with being a member! If you golf or are looking for fitness facilities in the Kansas City area, this is your next stop!
Anyone can copy your product - no one can copy your culture.
This presentation shows you how Gugin work with you to create a strong, sustainable corporate culture that supports your organisation's goals and aspirations
Monoids, Store, and Dependency Injection - Abstractions for Spark Streaming JobsRyan Weald
Talk I gave at a Spark Meetup on 01/16/2014
Abstract:
One of the most difficult aspects of deploying spark streaming as part of your technology stack is maintaining all the job associated with stream processing jobs. In this talk I will discuss the the tools and techniques that Sharethrough has found most useful for maintaining a large number of spark streaming jobs. We will look in detail at the way Monoids and Twitter's Algebrid library can be used to create generic aggregations. As well as the way we can create generic interfaces for writing the results of streaming jobs to multiple data stores. Finally we will look at the way dependency injection can be used to tie all the pieces together, enabling raping development of new streaming jobs.
(video and more at http://fsharpforfunandprofit.com/fppatterns)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID. The functional programming community has design patterns and principles as well. This talk will provide an overview of some of these patterns (such as currying, monads), and present some demonstrations of FP design in practice. We'll also look at some of the ways you can use these patterns as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
Workshop slides from the Alt.Net Seattle 2011 workshop. Presented by Wes Dyer and Ryan Riley. Get the slides and the workshop code at http://rxworkshop.codeplex.com/
(Video and code at https://fsharpforfunandprofit.com/pipeline/)
Passing data through a pipeline of transformations is an alternative approach to classic OOP. The LINQ methods in .NET are designed around this, but the pipeline approach can be used for so much more than manipulating collections.
In this talk, I'll look at pipeline-oriented programming and how it relates to functional programming, the open-closed principle, unit testing, the onion architecture, and more. I'll finish up by showing how you can build a complete web app using only this approach.
Types of C++ functions:
Standard functions
User-defined functions
C++ function structure
Function signature
Function body
Declaring and Implementing C++ functions
Let's make a contract: the art of designing a Java APIMario Fusco
An API is what developers use to achieve some task. More precisely it establishes a contract between them and the designers of the software exposing its services through that API. In this sense we're all API designers: our software doesn't work in isolation, but becomes useful only when it interacts with other software written by other developers. When writing software we're not only consumers, but also providers of one or more API and that's why every developer should know the features of a good API. During this presentation we will go through real-world examples, also taken from the standard Java API, of good and bad API and comment them in order to show the dos and don'ts of API design. More in general we will discuss the characteristics of an easy and pleasant to use API, like consistency, discoverability and understandability, together with some basic concepts like the principle of least astonishment, and find out how to achieve them.
Slides from a brief presentation about the 'docase' notation that I did at Haskell Hackathon in Cambridge. The notation makes it easier to work with monads that have some additional operations (such as Par monad or Parsers).
(Video available at http://fsharpforfunandprofit.com/monadster/)
You've got a pile of assorted functions lying around. Each one is useful and reliable, but they just don't fit together properly. How can you assemble them into a complete system that can stand on its own two feet and terrorize the local villagers?
In this session, I'll show how functional programming can transform all sorts of existing code into shapes that are plug-compatible and which can be bolted together effortlessly.
SAFETY NOTE: The techniques demonstrated are perfectly harmless and can even be used at your workplace -- no lightning bolts required.
A slideshow presentation by Doug Albers all about GreatLife KC, and the perks and amenities that come along with being a member! If you golf or are looking for fitness facilities in the Kansas City area, this is your next stop!
Anyone can copy your product - no one can copy your culture.
This presentation shows you how Gugin work with you to create a strong, sustainable corporate culture that supports your organisation's goals and aspirations
Advanced GeoServer Security with GeoFenceGeoSolutions
This presentation will provide an introduction to GeoFence, an open source tool to configure and use complex authorization rules to protect data served by GeoServer OGC services.
Publicize, promote and market your book with little or no marketing budgetTom Corson-Knowles
Most authors are so exhausted by the time they’ve finished their books – and often so strapped for cash – that they don’t know where to start a publicity and marketing campaign, especially with little or no budget. You don’t need a $20,000 publicist. Or a $5,000 assistant. If you have more time than money, you can do most of the publicity and marketing work yourself like a professional if you know what to do.
Brand differentiation is CRITICAL in today's ever-commoditizing marketplace. In their book Overthrow, Adam Morgan and Mark Holden identify the 10 different challenger stories. Every brand MUST be a challenger brand for success. Which one are you?
Gaursons is coming up with their commercial project Gaur City Centre with Sadar Bazar on First Floor and Wholesale Bazar on Second Floor at Gaur Chowk road Greater Noida West.
view more:- http://bit.ly/2l45EjF
Cheap carpet cleaning depends on the cleaning methods you choosecarpetcleaningau
If you want to get cheap carpet cleaning, you should start by learning all available methods for carpet cleaning and then decide after being aware of disadvantage and advantage of every method. After reviewing everything about these methods, then you may decide which option is cheap and which will be cost effective when it comes to clean your carpet.
Tamir Dresher - What’s new in ASP.NET Core 6Tamir Dresher
ASP.NET Core is a modern Web framework for .NET that gives you everything you need to build powerful backend services.
With .NET 6 things are simpler than ever before and there are many new features that will make your development fun and fast.
In this session we'll explore all the cool and new things that were added and all that changes that make ASP.NET Core 6 the best web framework
Wprowadzenie do technologii Big Data / Intro to Big Data EcosystemSages
Introduction to Hadoop Map Reduce, Pig, Hive and Ambari technologies.
Workshop deck prepared and presented on September 5th 2015 by Radosław Stankiewicz.
During that the day participants had also the possibility to go through prepared tutorials and test their analysis on real cluster.
GDG Devfest 2019 - Build go kit microservices at kubernetes with easeKAI CHU CHUNG
Gokit is microservice tookit and use Service/Endpoint/Transport to strict separation of concerns design. This talk to use go-kit develop microservice application integrate with consul, zipkin, prometheus, etc service and deploy on Kubernetes.
This session is recommended for anyone interested in building real-time streaming applications using AWS. In this session, you will get a deep understanding of how data can be ingested by Amazon Kinesis and made available for real-time analysis and processing. We’ll also show how you can leverage the Kinesis client to make your applications highly available and fault tolerant. We’ll explore various design considerations in implementing real-time solutions and explain key concepts against the backdrop of an actual use case. Finally, we’ll situate stream processing in the broader context of your big data applications.
Modern web applications have constantly growing requirements and their complexity grows exponentially. Some of the biggest challenges in front of us are state management, testability, flexibility and on top of that we need to develop the application at reasonable level of simplicity in order to ease the recruitment process.
In this presentation I'll introduce a scalable Angular 2 application architecture, which answers the following requirements:
- Testability.
- Predictable state management.
- Scalable communication layer.
- Modular and robust design
[HKOSCon 2020] Build an api service using ktor rapidlyShengyou Fan
Kotlin is not only for mobile development but also for backend (it could be used everywhere actually!). In JetBrains, we build Ktor framework for backend development such as website, API, microservice. In this talk, I will introduce what Ktor is, how to integrated with Exposed SQL library, demonstrate how to build a RESTful API service in just a few lines of code. After listening to this talk, you will learn how to build API with Ktor rapidly.
Presented this talk at AltConf 2019. Covers typical REST API approach to syncing data between servers and mobile apps; then discusses how new eventually consistent databases with syncing technology built in can be used to make syncing simpler and easier to work with.
Sharding and Load Balancing in Scala - Twitter's FinagleGeoff Ballinger
My presentation at Mostly Functional (http://mostlyfunctional.com), part of this year's Turing Festival Fringe (http://turingfestival.com) in Edinburgh. The example source code is up on Github at https://github.com/geoffballinger/simple-sharder
Get to know the two stateful programming models of Azure Serverless compute: workflows and actors and how these models can simplify development and how they enable stateful and long-running application patterns within Azure’s compute environments.
1. what is the different unbuffered and buffered channel?
2. how to implement a job queue in golang?
3. how to stop the worker in a container?
4. Shutdown with Sigterm Handling
5. Canceling Workers without Context
6. Graceful shutdown with worker
7. How to auto-scaling build agent?
8. How to cancel the current Job?
Reactive Programming Patterns with RxSwiftFlorent Pillet
In this introduction to reactive programming and RxSwift you'll learn how common problems are solved in a reactive way to improve your architecture and write more reliable code.
Java/Scala Lab: Анатолий Кметюк - Scala SubScript: Алгебра для реактивного пр...GeeksLab Odessa
SubScript - это расширение языка Scala, добавляющее поддержку конструкций и синтаксиса аглебры общающихся процессов (Algebra of Communicating Processes, ACP). SubScript является перспективным расширением, применимым как для разработки высоконагруженных параллельных систем, так и для простых персональных приложений.
An exploration into RxJava on Android for the experienced, yet uninitiated software engineer. This presentation explores Declarative vs Imperative programming paradigms and expands the discussion into Functional Reactive Programming. It explains the benefits of the observer contract, high-order functions, and schedulers available in RxJava. It also explains the purpose of the Android integration libraries: RxAndroid, RxLifecycle, and RxBindings.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...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.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
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.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
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/
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
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
8. Some new things to learn…
recursion
pure functions
immutable data
partial application
let rec qsort = function
| [] -> []
| hd :: tl ->
let lesser, greater = List.partition ((>=) hd) tl
List.concat [qsort lesser; [hd]; qsort greater]
pattern matching
higher-order functions
type inference
generics by default
'a list -> 'a list when 'a : comparison
9. let rec qsort = function
| [] -> []
| hd :: tl ->
let lesser, greater = List.partition ((>=) hd) tl
List.concat [qsort lesser; [hd]; qsort greater]
gotcha!
10. Some real-world concerns…
•
Good for demos but what about large
programs?
•
Good for academics but what about us?
•
Elegant code but what about performance?
•
Does it work with legacy software?
•
Where do I find functional programmers?
11.
12. Bespoke Enterprise Applications
for the Energy Sector
•
lots of data
•
forecasts
•
•
•
metered data
market data
lots of types
•
units of measure
•
lots of computations
•
schedules
•
contracts
•
analysis
rates
•
•
station parameters
… all changing over time
20. Real-world OO
•
Struggles to be elegant
•
top down designs
•
•
high ceremony
•
•
coarse abstractions
data and behaviour tightly coupled
Mutating state is a powerful and dangerous
technique
•
hard to reason about
•
requires synchronised access
Lots of accidental complexity
•
abstraction event horizon
•
•
•
ORMs, IoCs, Mocks, Design Patterns,
UML …
Hard to find developers who have mastered
all of this
22. Not-Only SQL
•
most applications do not require the
flexibility a relational schema affords
•
•
applications are written in terms of
aggregates not relational schemas
•
•
as-of
store inputs and outputs
•
avoid accidental
complexity: ORM,
normal form
persist aggregates
making aggregates immutable affords
•
•
separate reporting concerns from
application concerns
what-if, easy test and debug
fits well with
functional
programs
23. JSON Documents
Input
• RunID
• Contract Parameters
• Asset Parameters
• Dynamic Parameters
• Market Parameters
JobRequest
• RunID
• Contract
• Interval
Pure
Function
Contract
Evaluation
API
Scheduler
Contract
Evaluation
Job API
Output
• RunID
• Revenue
• Additional Information
Document
Store
“Pure I/0”
Input
Output
24.
25. Adoption: F#
•
Low risk
•
Runs on CLR and mono
•
Open source
•
Inter-op with legacy software and libraries
•
Back-out to C#
26. Adoption: Developers
•
Self taught
•
Hire good .NET developers, not language x
developers
•
.NET developer cutting F# production code in
a week
•
Functional programmer in a month
29. Self-host Web API
let config = new HttpSelfHostConfiguration(baseAddress)
config.MapHttpAttributeRoutes()
config.Formatters.JsonFormatter.SerializerSettings <-
JsonSerializerSettings(
PreserveReferencesHandling = PreserveReferencesHandling.None,
Converters =
[|
Json.TupleConverter()
Json.OptionConverter()
Json.ArrayConverter()
Json.ListConverter()
Json.MapTypeConverter()
Json.UnionTypeConverter()
|])
config.DependencyResolver <- new UnityResolver(container)
F# type JSON
converters
30. Topshelf Windows Service
F# working with an
existing
OO framework
HostFactory.Run(fun hc ->
hc.UseLog4Net("log4net.config")
hc.SetServiceName("Job.Api.Host")
hc.SetDisplayName("E.ON Ancillary Services Job API Host")
hc.SetDescription("An API service for Ancillary Services Jobs.")
hc.RunAsNetworkService() |> ignore
hc.Service<ApiService>(fun (s: ServiceConfigurator<ApiService>) ->
s.ConstructUsing(fun (name: string) -> new ApiService(config)) |> ignore
s.WhenStarted(fun (svc: ApiService) ->
jobRequestQueue.Start()
svc.Start()) |> ignore
s.WhenStopped(fun (svc: ApiService) ->
svc.Stop()
jobRequestQueue.Stop())
|> ignore)
|> ignore)
31. Web API Service
an F# class!!!
type ApiService(config: HttpSelfHostConfiguration) =
!
member val Server =
new HttpSelfHostServer(config) with get, set
!
member this.Start() =
this.Server.OpenAsync().Wait()
member this.Stop() =
if this.Server <> null then
this.Server.CloseAsync().Wait()
this.Server.Dispose()
32. Web API Controller
another F# class!!!
type JobController(log: ILog, jobRequestQueue: JobRequestQueue)
inherit ApiController()
!
[<Route("job/ping")>]
member x.Get() =
log.Debug("ping!!!")
"pong"
[<Route("job")>]
member x.Post(request:JobRequest) =
jobRequestQueue.Add(request)
33. agents: the safe way to manage state
Job Queue
let requests = BlockingQueueAgent<JobRequest>(config.JobRequestQueueLength)
!
let workerName (i: int) = String.Format("worker[{0}]", i)
!
let worker (workerName: string) =
async {
while true do
log.DebugFormat("{0} free", workerName)
let! request = requests.AsyncGet()
log.DebugFormat("{0} busy: job {1}", workerName, request.JobId)
run request
}
async, efficient use of threads
!
for i in 1 .. config.JobRequestWorkers do
Async.Start(workerName i |> worker, CancellationToken.Token)
!
requests.Add(request)
scale workers
github.com/fsprojects/fsharpx/blob/master/src/FSharpx.Core/Agents/
BlockingQueueAgent.fs
34. Execute Job
composition of async computations
async {
let! input = buildRequest dataProvider
let! output = sendToCompute input
let result = buildModel input output
do! store result
}
{
35. Post
dispose of resource when done
async {
use! response =
httpClient.PostAsync(uri, toContent request)
|> Async.AwaitTask
return!
response.EnsureSuccessStatusCode().Content.ReadAsStringAsync()
|> Async.AwaitTask
}
F# async works with TPL Tasks
39. Ubiquitous Language
(Revised)
segment is an event
module Segment =
!
segment holds a value
over an interval
type T<'x,'y> =
| Instantaneous of Point.T<'x,'y>
| Discrete of IntervalType.T * Interval.T<'x> * 'y
| Continuous of Point.T<'x,'y> * Point.T<'x,'y>
segment between two data points
40. module Units =
!
Units of Measure
[<AutoOpen>]
module UnitNames =
/// a unit of time
[<Measure>] type minute
/// a unit of time
[<Measure>] type halfhour
/// a unit of time
[<Measure>] type hour
/// a unit of active power
[<Measure>] type megawatt
/// a unit of energy
[<Measure>] type poundssterling
/// a unit of frequency
[<Measure>] type hertz
[<AutoOpen>]
module UnitSymbols =
/// a synonym for halfhour, a unit of time
[<Measure>] type min = minute
/// a synonym for halfhour, a unit of time
[<Measure>] type hh = halfhour
/// a synonym for hour, a unit of time
[<Measure>] type h = hour
/// a synonym for megawatt, a unit of power
[<Measure>] type MW = megawatt
/// a synonym for pounds sterling, a unit of currency
[<Measure>] type ``£`` = poundssterling
/// a synonym for hertz, a unit of frequency
[<Measure>] type Hz = hertz
https://github.com/fsharp/fsharp/blob/master/src/fsharp/FSharp.Core/SI.fs
41. Units of Measure
// Conversion constants
let minutePerHalfhour = 30.0<min>/1.0<hh>
let minutePerHour = 60.0<min>/1.0<h>
let halfhourPerMinute = 1.0<hh>/30.0<min>
let halfhourPerHour = 2.0<hh>/1.0<h>
let hourPerMinute = 1.0<h>/60.0<min>
let hourPerHalfhour = 1.0<h>/2.0<hh>
module Minute =
let toHalfhour (a:float<min>) = a * halfhourPerMinute
let toHour (a:float<min>) = a * hourPerMinute
let inline lift a = LanguagePrimitives.FloatWithMeasure<min>(float a)
let liftTimeSpan (t:TimeSpan) = lift t.TotalMinutes
42. Contract Evaluation
to
p
let run interval initialState parameters
actualFrequencies targetFrequencies marketPrices pdtmLine =
let deloadLine = DeloadLineCalculation.run …
let holdingPayments = holdingPayments …
let referencePrices = ReferencePriceCalculation.run …
responseEnergyPayments …
se
cr
et
… but it involves a fold
43. Testing
// Straight forward implementation
!
let rec reverse = function
| [] -> []
| x::xs -> reverse xs @ [x]
!
// Efficient implementation
!
let rec revAcc xs acc =
match xs with
| [] -> acc
| h::t -> revAcc t (h::acc)
!
let rev xs =
match xs with
| [] -> xs
| [_] -> xs
| h1::h2::t -> revAcc t [h2;h1]
!
// Generate random tests to see if they behave the same
!
Check.Quick(fun (xs:int list) -> reverse xs = rev xs)
github.com/fsharp/FsCheck
44. Testing
nice names
open NUnit.Framework
open FsUnit
!
[<TestFixture; Category("Unit")>]
type ``When I run the deload line calculation`` () =
!
[<Test>]
member x.``with empty MEL line and empty PN line then the deload line is correct`` () =
let melLine = Line.empty
let pnLine = Line.empty
let actual = DeloadLineCalculation.run melLine pnLine
let expected : Line.Time.T<float<MW>> = Line.empty
actual |> should equal expected
structural equality for free
github.com/fsharp/FsUnit
45.
46. C#
F#
Two Implementations of the Same Application
400000
30,801
348,430
21,442
Lines of Code
300000
305,566
200000
16,667
163,276
100000
643
56,929
487
53,270
9,359
42,864
3,630
29,080
0
15
3,011
Braces
Blanks
Null Checks
Comments
Useful Code
App Code
Test Code
Total Code
47. … things aren’t looking good for the old
way of doing things
53. Manifesto for Not Only Object-Oriented Development!
We are uncovering better ways of developing software by doing
it and helping others do it. Through this work we have come to
value:
!
•
•
•
•
•
0b
ov
Functions and Types over classes
0, er
si
gn 00
Purity over mutability
0,
at
Composition over inheritance
or 0 0
0
Higher-order functions over method dispatch
ie
s!
Options over nulls
10
!
That is, while there is value in the items on the right (except for
nulls), we value the items on the left more.
notonlyoo.org