There’s a lot of exciting new stuff in .NET Core, and more on the way! We’ll take a look at some top features in 3.1, including Blazor, desktop support (WPF and Windows Forms), single file executables, language features, and more. We'll also take an early look at what's on the way in .NET 5, and how you can start planning for it today.
What's new in Visual Studio for Mac for .NET DevelopersJon Galloway
An overview of recent, just landed, and upcoming features for .NET developers on macOS.
Presentation to Seattle Mobile .NET (Xamarin) Developers Group, April 8, 2020.
gRPC is a modern high performance RPC (Remote Procedure Call) framework that can run in any environment. gRPC is based on HTTP/2, Protocol Buffers and other modern standard-based technologies. Together with excellent tooling, it helps you create high throughput, low latency, real-time services.
Introduction to gRPC: A general RPC framework that puts mobile and HTTP/2 fir...Codemotion
gRPC is a high performance, language-neutral, general RPC framework developed and open sourced by Google. Built on the HTTP/2 standard, gRPC brings many benefits such as bidirectional streaming, flow control, header compression, multiplexing and more. In this session, you will learn about gRPC and how you can use it in your applications.
In this talk we will discuss the use of gRPC to build a microservices-based application on Kubernetes. We’ll firstly focus on the basic concepts of gRPC: protocol buffers, code generation and HTTP 2.0. We’ll then discuss some more intermediate-level features, such as native Kubernetes load balancing, gRPC streaming, error propagation, HTTP tunneling and instrumentation. Finally we’ll touch on some of the newer, exciting developments in the space: middleware and context propagation for distributed tracing, gRPC Web for client-side rich web apps and gogoproto for blazing-fast generated code. This talk is based on my experience building a hosted, Prometheus-based monitoring service, which itself used gRPC for all intra-server communication and runs on Kubernetes. There’ll be live coding, real world examples and discussion of the benefits (and drawbacks) of gRPC.
Presented at GDG Devfest Ukraine 14th Oct 2017.
Abstract:
Jini has served Orbitz well, but at the cost of tight coupling due in part to shared code and Java™ platform serialization rules. To improve agility, Orbitz is migrating to a RESTful Web services architecture using protocol buffers to define message formats. The result is loosely coupled services with autonomous lifecycles supporting evolvability and innovative mashup-style development.
This session is intended for experienced architects and tech leads who are familiar with distributed systems and data encoding methods.
It covers
• Using document schemas to constitute language-neutral contracts
• Using standard HTTP plumbing and intermediaries
• Implementing a reverse proxy for request routing based on RESTful URLs
• Applying OLAs for governance and service isolation
• Writing automated service layer tests to ensure backward compatibility
Spend some time working with OpenAPI and gRPC and you’ll notice that these two technologies have a lot in common. Both are open source efforts, both describe APIs, and both promise better experiences for API producers and consumers. So why do we need both? If we do, what value does each provide? What can each project learn from the other? We’ll bring the two together for a side-by-side comparison and pose answers to these and other questions about two API methodologies that will do much to influence the future of networked APIs.
What's new in Visual Studio for Mac for .NET DevelopersJon Galloway
An overview of recent, just landed, and upcoming features for .NET developers on macOS.
Presentation to Seattle Mobile .NET (Xamarin) Developers Group, April 8, 2020.
gRPC is a modern high performance RPC (Remote Procedure Call) framework that can run in any environment. gRPC is based on HTTP/2, Protocol Buffers and other modern standard-based technologies. Together with excellent tooling, it helps you create high throughput, low latency, real-time services.
Introduction to gRPC: A general RPC framework that puts mobile and HTTP/2 fir...Codemotion
gRPC is a high performance, language-neutral, general RPC framework developed and open sourced by Google. Built on the HTTP/2 standard, gRPC brings many benefits such as bidirectional streaming, flow control, header compression, multiplexing and more. In this session, you will learn about gRPC and how you can use it in your applications.
In this talk we will discuss the use of gRPC to build a microservices-based application on Kubernetes. We’ll firstly focus on the basic concepts of gRPC: protocol buffers, code generation and HTTP 2.0. We’ll then discuss some more intermediate-level features, such as native Kubernetes load balancing, gRPC streaming, error propagation, HTTP tunneling and instrumentation. Finally we’ll touch on some of the newer, exciting developments in the space: middleware and context propagation for distributed tracing, gRPC Web for client-side rich web apps and gogoproto for blazing-fast generated code. This talk is based on my experience building a hosted, Prometheus-based monitoring service, which itself used gRPC for all intra-server communication and runs on Kubernetes. There’ll be live coding, real world examples and discussion of the benefits (and drawbacks) of gRPC.
Presented at GDG Devfest Ukraine 14th Oct 2017.
Abstract:
Jini has served Orbitz well, but at the cost of tight coupling due in part to shared code and Java™ platform serialization rules. To improve agility, Orbitz is migrating to a RESTful Web services architecture using protocol buffers to define message formats. The result is loosely coupled services with autonomous lifecycles supporting evolvability and innovative mashup-style development.
This session is intended for experienced architects and tech leads who are familiar with distributed systems and data encoding methods.
It covers
• Using document schemas to constitute language-neutral contracts
• Using standard HTTP plumbing and intermediaries
• Implementing a reverse proxy for request routing based on RESTful URLs
• Applying OLAs for governance and service isolation
• Writing automated service layer tests to ensure backward compatibility
Spend some time working with OpenAPI and gRPC and you’ll notice that these two technologies have a lot in common. Both are open source efforts, both describe APIs, and both promise better experiences for API producers and consumers. So why do we need both? If we do, what value does each provide? What can each project learn from the other? We’ll bring the two together for a side-by-side comparison and pose answers to these and other questions about two API methodologies that will do much to influence the future of networked APIs.
A history of how the microservice evolved into what it is today. A further dive into the building blocks of the most dominant technology in this space - kubernetes!
Presentation at NetPonto community: "We’re going to discuss gRPC, Google’s open-source RPC framework. I’ll dive a bit into the history of RPC as a protocol, and what its historical use has been. I’ll also highlight some benefits to adopt gRPC and how its possible to swap out parts of gRPC and still take advantage of gRPC’s benefits. Finally I’ll answer the question that has been on many lips since gRPC was announced — what does this mean for REST?"
HTTP2 in action - Piet Van Dongen - Codemotion Amsterdam 2017Codemotion
We've all heard about HTTP/2, but what's in it for us? Is it really that much better? How can we start using it? During this talk, we will explore HTTP/2's new features while creating our own web server, demonstrating new features like server push, multiplexing and header compression. At then end, we can proof how HTTP/2 benefits not only the end user, but developers and operations as well!.
The Internet of Things if growing, but how can you build your own connected objects?
Together with MQTT, CoAP is one of the popular IoT protocols. It provides answers to the typical IoT constraints: it is bandwidth efficient and fits in constrained embedded environment while providing friendly and discoverable RESTful API.
This tutorial aims at giving you a hands-on experience with CoAP by showing you the power and simplicity of the Eclipse Californium library for developing real world IoT application.
Agenda:
- Introduction to CoAP
- Live discovery of connected CoAP objects using the Copper plugin for Firefox
- Presentation of more advanced CoAP topics (proxy, resource directory, device management with LWM2M)
- Presentation of Eclipse Californium, a CoAP library for Java
- Exercise: complete the provided Java code to create your own Internet of Things... thing!
A short introductory talk given as part of the April 2018 Kong meetup "Introducing Kubernetes Ingress Controller for Kong".
This talk covers the new features and improvements made to Kong from 2017 to 2018, including the groundwork conducted by Kong Inc. and open source contributors that allowed for the development of the Kong Ingress Controller for Kubernetes.
The Kong Ingress Controller for Kubernetes was then announced during the meetup:
https://github.com/Kong/kubernetes-ingress-controller
Bringing Learnings from Googley Microservices with gRPC - Varun Talwar, GoogleAmbassador Labs
Varun Talwar, product manager on Google's gRPC project discusses the fundamentals and specs of gRPC inside of a Google-scale microservices architecture.
Building high performance microservices in finance with Apache ThriftRX-M Enterprises LLC
Apache Roadshow Chicago Talk on May 14, 2019
In this talk we’ll look at the ways Apache Thrift can solve performance problems commonly facing next generation applications deployed in performance sensitive capital markets and banking environments. The talk will include practical examples illustrating the construction, performance and resource utilization benefits of Apache Thrift. Apache Thrift is a high-performance cross platform RPC and serialization framework designed to make it possible for organizations to specify interfaces and application wide data structures suitable for serialization and transport over a wide variety of schemes. Due to the unparalleled set of languages supported by Apache Thrift, these interfaces and structs have similar interoperability to REST type services with an order of magnitude improvement in performance. Apache Thrift services are also a perfect fit for container technology, using considerably fewer resources than traditional application server style deployments. Decomposing applications into microservices, packaging them into containers and orchestrating them on systems like Kubernetes can bring great value to an organization; however, it can also take a very fast monolithic application and turn it into a high latency web of slow, resource hungry services. Apache Thrift is a perfect solution to the performance and resource ills of many microservice based endeavors.
JavaZone 2016 : MQTT and CoAP for the Java DeveloperMark West
After HTTP, MQTT and CoAP are perhaps the most commonly used communication protocols for connecting devices to the Internet of Things. But what are MQTT and CoAP, and what benefits do they provide over plain old HTTP?
In this session we’ll start by looking at the limitations to using HTTP in the IoT world. We will then introduce MQTT and CoAP, and explain why these can be compelling replacements for HTTP. By examining the strengths and weaknesses for HTTP, MQTT and CoAP we’ll identify IoT use cases for all three.
At Splunk, we have made the decision to deprecate a home-brewed platform that powers the DSP's (Data Stream Processor) connector framework in favor of a framework that is powered by Pulsar IO.
In this talk, I will go over our evaluation and decision process on choosing to use the Pulsar IO framework. I will also discuss how the Splunk's DSP product is leveraging the Pulsar IO framework and especially batch sources that was recently added to Pulsar IO. I will conclude the talk with discussing the various improvements that we at Splunk have contributed to the Pulsar Functions/IO framework to increase scalability and stability. In my final remarks, I will also discuss how we intend to leverage and use Pulsar IO/Functions further in the future at Splunk.
10 Lessons Learned from using Kafka in 1000 microservices - ScalaUANatan Silnitsky
Kafka is the bedrock of Wix’s distributed Mega Microservices system.
Over the years we have learned a lot about how to successfully scale our event-driven architecture to roughly 1400 mostly Scala microservices.
In this talk, you will learn about 10 key decisions and steps you can take in order to safely scale-up your Kafka-based system.
These Include:
* How to increase dev velocity of event-driven style code.
* How to optimize working with Kafka in polyglot setting
* How to migrate from request-reply to event-driven
* How to tackle multiple DCs environment.
Kat Grigg, Confluent, Senior Customer Success Architect + Jen Snipes, Confluent, Senior Customer Success Architect
This presentation will cover tips and best practices for Apache Kafka. In this talk, we will be covering the basic internals of Kafka and how these components integrate together including brokers, topics, partitions, consumers and producers, replication, and Zookeeper. We will be talking about the major categories of operations you need to be setting up and monitoring including configuration, deployment, maintenance, monitoring and then debugging.
https://www.meetup.com/KafkaBayArea/events/270915296/
Slides for the talk in Ruby SG meetup. (Apr 2018)
https://github.com/sathiyaseelan/grpc-client-ruby
https://github.com/sathiyaseelan/grpc-client-go
https://github.com/sathiyaseelan/grpc-rails-api
In questa sessione andremo in dettaglio sulle principali novità introdotte nella versione 3.0 di ASP.NET Core.
Code: https://github.com/andreadottor/VSSaturdayPN2019
A history of how the microservice evolved into what it is today. A further dive into the building blocks of the most dominant technology in this space - kubernetes!
Presentation at NetPonto community: "We’re going to discuss gRPC, Google’s open-source RPC framework. I’ll dive a bit into the history of RPC as a protocol, and what its historical use has been. I’ll also highlight some benefits to adopt gRPC and how its possible to swap out parts of gRPC and still take advantage of gRPC’s benefits. Finally I’ll answer the question that has been on many lips since gRPC was announced — what does this mean for REST?"
HTTP2 in action - Piet Van Dongen - Codemotion Amsterdam 2017Codemotion
We've all heard about HTTP/2, but what's in it for us? Is it really that much better? How can we start using it? During this talk, we will explore HTTP/2's new features while creating our own web server, demonstrating new features like server push, multiplexing and header compression. At then end, we can proof how HTTP/2 benefits not only the end user, but developers and operations as well!.
The Internet of Things if growing, but how can you build your own connected objects?
Together with MQTT, CoAP is one of the popular IoT protocols. It provides answers to the typical IoT constraints: it is bandwidth efficient and fits in constrained embedded environment while providing friendly and discoverable RESTful API.
This tutorial aims at giving you a hands-on experience with CoAP by showing you the power and simplicity of the Eclipse Californium library for developing real world IoT application.
Agenda:
- Introduction to CoAP
- Live discovery of connected CoAP objects using the Copper plugin for Firefox
- Presentation of more advanced CoAP topics (proxy, resource directory, device management with LWM2M)
- Presentation of Eclipse Californium, a CoAP library for Java
- Exercise: complete the provided Java code to create your own Internet of Things... thing!
A short introductory talk given as part of the April 2018 Kong meetup "Introducing Kubernetes Ingress Controller for Kong".
This talk covers the new features and improvements made to Kong from 2017 to 2018, including the groundwork conducted by Kong Inc. and open source contributors that allowed for the development of the Kong Ingress Controller for Kubernetes.
The Kong Ingress Controller for Kubernetes was then announced during the meetup:
https://github.com/Kong/kubernetes-ingress-controller
Bringing Learnings from Googley Microservices with gRPC - Varun Talwar, GoogleAmbassador Labs
Varun Talwar, product manager on Google's gRPC project discusses the fundamentals and specs of gRPC inside of a Google-scale microservices architecture.
Building high performance microservices in finance with Apache ThriftRX-M Enterprises LLC
Apache Roadshow Chicago Talk on May 14, 2019
In this talk we’ll look at the ways Apache Thrift can solve performance problems commonly facing next generation applications deployed in performance sensitive capital markets and banking environments. The talk will include practical examples illustrating the construction, performance and resource utilization benefits of Apache Thrift. Apache Thrift is a high-performance cross platform RPC and serialization framework designed to make it possible for organizations to specify interfaces and application wide data structures suitable for serialization and transport over a wide variety of schemes. Due to the unparalleled set of languages supported by Apache Thrift, these interfaces and structs have similar interoperability to REST type services with an order of magnitude improvement in performance. Apache Thrift services are also a perfect fit for container technology, using considerably fewer resources than traditional application server style deployments. Decomposing applications into microservices, packaging them into containers and orchestrating them on systems like Kubernetes can bring great value to an organization; however, it can also take a very fast monolithic application and turn it into a high latency web of slow, resource hungry services. Apache Thrift is a perfect solution to the performance and resource ills of many microservice based endeavors.
JavaZone 2016 : MQTT and CoAP for the Java DeveloperMark West
After HTTP, MQTT and CoAP are perhaps the most commonly used communication protocols for connecting devices to the Internet of Things. But what are MQTT and CoAP, and what benefits do they provide over plain old HTTP?
In this session we’ll start by looking at the limitations to using HTTP in the IoT world. We will then introduce MQTT and CoAP, and explain why these can be compelling replacements for HTTP. By examining the strengths and weaknesses for HTTP, MQTT and CoAP we’ll identify IoT use cases for all three.
At Splunk, we have made the decision to deprecate a home-brewed platform that powers the DSP's (Data Stream Processor) connector framework in favor of a framework that is powered by Pulsar IO.
In this talk, I will go over our evaluation and decision process on choosing to use the Pulsar IO framework. I will also discuss how the Splunk's DSP product is leveraging the Pulsar IO framework and especially batch sources that was recently added to Pulsar IO. I will conclude the talk with discussing the various improvements that we at Splunk have contributed to the Pulsar Functions/IO framework to increase scalability and stability. In my final remarks, I will also discuss how we intend to leverage and use Pulsar IO/Functions further in the future at Splunk.
10 Lessons Learned from using Kafka in 1000 microservices - ScalaUANatan Silnitsky
Kafka is the bedrock of Wix’s distributed Mega Microservices system.
Over the years we have learned a lot about how to successfully scale our event-driven architecture to roughly 1400 mostly Scala microservices.
In this talk, you will learn about 10 key decisions and steps you can take in order to safely scale-up your Kafka-based system.
These Include:
* How to increase dev velocity of event-driven style code.
* How to optimize working with Kafka in polyglot setting
* How to migrate from request-reply to event-driven
* How to tackle multiple DCs environment.
Kat Grigg, Confluent, Senior Customer Success Architect + Jen Snipes, Confluent, Senior Customer Success Architect
This presentation will cover tips and best practices for Apache Kafka. In this talk, we will be covering the basic internals of Kafka and how these components integrate together including brokers, topics, partitions, consumers and producers, replication, and Zookeeper. We will be talking about the major categories of operations you need to be setting up and monitoring including configuration, deployment, maintenance, monitoring and then debugging.
https://www.meetup.com/KafkaBayArea/events/270915296/
Slides for the talk in Ruby SG meetup. (Apr 2018)
https://github.com/sathiyaseelan/grpc-client-ruby
https://github.com/sathiyaseelan/grpc-client-go
https://github.com/sathiyaseelan/grpc-rails-api
In questa sessione andremo in dettaglio sulle principali novità introdotte nella versione 3.0 di ASP.NET Core.
Code: https://github.com/andreadottor/VSSaturdayPN2019
gRPC is a modern high performance RPC (Remote Procedure Call) framework that can run in any environment. gRPC is based on HTTP/2, Protocol Buffers and other modern standard-based technologies. Together with excellent tooling, it helps you create high throughput, low latency, real-time services.
【BS1】What’s new in visual studio 2022 and c# 10日本マイクロソフト株式会社
Watch this session to learn about the new capabilities in Visual Studio 2022 and the new C# 10 features for .NET developers. With Visual Studio 2022, you'll always get the best-in-class tools and services available for any developer, any app, and any platform. Whether you're using Visual Studio for the first time, or you've been using it for years, there's a lot to like in our newest version.
C# 8 and .NET Core 3.0 will be released in 2019. In this session you learn what’s new with these new major versions. Influenced on language enhancements such as async streams and nullable reference types, enhancements based on this are coming to .NET Core and EF Core. With ASP.NET Core, a new routing foundation is available. You’ll see advantages of the new endpoint routing in addition to the Blazor Components, and some new project templates. Last but not least, you learn about different aspects and features creating WPF applications with .NET Core 3.0.
Xamarin Form using ASP.NET Core SignalR clientChen Yu Pao
A little introduction of ASP.NET Core SignalR and How to connect it using official .Net Standard 2.0 C# client library in Xamarin.Forms project for Front-end Developer.
An introduction to SignalR
This deck was part of my presentation to Virtusa employees on an ASP.NET asynchronous, persistent signaling library known as SignalR
There is also a slide on how to use SignalR with SharePoint.
Date: August 2013
Follow / Tweet me: @ShehanPeruma
What's new with .NET Core 3 - covering features from C#, .NET Core, ASP.NET Core, WPF - including nullability, indices and ranges, switch expressions, enhanced pattern matching, changes with ASP.NET Core, Blazor server-side components, and WPF with .NET Core.
Keynote: Hijacking Boring Sounding Things Like Foundations and Maturity Model...Jon Galloway
Jon has been the executive director of the .NET Foundation since February, and one of his most difficult tasks when he was first starting was figuring out how to describe what the .NET Foundation actually is, let alone why anyone should actually care. How much fun could a foundation be, really? But what if foundations, maturity models were the key to taking .NET open source to the next level and making developing a lot more exciting? And if they are, how could we take it even further?
Video from the presentation here: https://skillsmatter.com/skillscasts/10192-keynote-hijacking-boring-sounding-things-like-foundations-and-maturity-models-to-make-open-source-more-fun
Slides from my presentation at .NET Southeast, Brighton. More information at https://blogs.msdn.microsoft.com/webdev/2017/08/14/announcing-asp-net-core-2-0/ and https://blogs.msdn.microsoft.com/webdev/2017/08/25/asp-net-core-2-0-features-1/
[NDC Oslo 2017] Open Source Software Foundations: Not Totally Boring, Actuall...Jon Galloway
Foundations sound horribly boring, but if you love building and using open source software, they're actually really cool.
I've been the executive director of the .NET Foundation since February, and one of my most difficult tasks when I was first starting was figuring out how to describe what the .NET Foundation actually is, let alone why anyone should actually care.Foundations can do a lot for the community, and maybe for your open source project. After getting you hyped out of your minds on what software foundations do for you today, we'll talk about where they could possibly go tomorrow.
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.
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.
"Impact of front-end architecture on development cost", Viktor TurskyiFwdays
I have heard many times that architecture is not important for the front-end. Also, many times I have seen how developers implement features on the front-end just following the standard rules for a framework and think that this is enough to successfully launch the project, and then the project fails. How to prevent this and what approach to choose? I have launched dozens of complex projects and during the talk we will analyze which approaches have worked for me and which have not.
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
Search and Society: Reimagining Information Access for Radical FuturesBhaskar Mitra
The field of Information retrieval (IR) is currently undergoing a transformative shift, at least partly due to the emerging applications of generative AI to information access. In this talk, we will deliberate on the sociotechnical implications of generative AI for information access. We will argue that there is both a critical necessity and an exciting opportunity for the IR community to re-center our research agendas on societal needs while dismantling the artificial separation between the work on fairness, accountability, transparency, and ethics in IR and the rest of IR research. Instead of adopting a reactionary strategy of trying to mitigate potential social harms from emerging technologies, the community should aim to proactively set the research agenda for the kinds of systems we should build inspired by diverse explicitly stated sociotechnical imaginaries. The sociotechnical imaginaries that underpin the design and development of information access technologies needs to be explicitly articulated, and we need to develop theories of change in context of these diverse perspectives. Our guiding future imaginaries must be informed by other academic fields, such as democratic theory and critical theory, and should be co-developed with social science scholars, legal scholars, civil rights and social justice activists, and artists, among others.
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.
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
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
12. Safe
Nullable and non-nullable
reference types help you write
safer code
Declare your intent more clearly
Modern
Async streams for modern
workloads like cloud & IoT
communication
Easily work with cloud scale
datasets using indexes and
ranges
Productive
Write less code using patterns
Protect data with readonly
members
Improved using statements for
resource management
13.
14.
15.
16.
17.
18.
19. Readonly members
Default interface
methods
Pattern matching
(Switch expressions,
Property & Tuple
patterns)
Positional patterns Using declarations
Static local
functions
Disposable ref
structs
Nullable reference
types
Asynchronous
streams
Indices and ranges
Null-coalescing
assignment
Unmanaged
constructed types
Stackalloc in nested
expressions
Enhancement of
interpolated
verbatim strings
https://aka.ms/new-csharp
21. Deployment Flexibility
Side-by-side deployment, self-
contained EXEs
Install machine global or app local
framework
Windows 10
Access modern Windows 10
APIs from WPF and WinForms
Use native Windows 10
controls via XAML islands
Open Source
WPF and WinForms projects
also open source on GitHub
Take advantage of
performance, runtime and API
improvements happening in
.NET Core
26. gRPC
High performance contract-
based RPC services with .NET
Works across many languages
and platforms
Worker Service
Starting point for long running
back processes like Windows
Server or Linux daemon
Producing or consuming
messages from a message
queue
Web API’s + Identity
Add security and authentication
to Web API’s
27. gRPC is…
• Popular open source RPC framework
• Largest RPC mindshare
• Cloud Native Computing Foundation project
• gRPC stands for gRPC Remote Procedure Calls
• Built with modern technologies
• HTTP/2
• Protocol Buffers
• Designed for modern apps
• High performance
• Platform independent
+ =
28. Protobuf (aka Protocol Buffers)
• IDL (interface definition language)
Describe once and generate interfaces for
any language
• Service model
Service method and structure of the
request and the response
• Wire format
Binary format for network transmission
syntax = "proto3";
message SubscribeRequest {
string topic = 1;
}
message Event {
int32 id = 1;
string details = 2;
}
service Topics {
rpc Subscribe(SubscribeRequest)
returns (stream Event);
}
5052 4920 2a20 4854 5450 2f32
0d0a 534d 0d0a 0d0a 0000 0004
0000 0000 0401 0000 0000 0000
29. Remote Procedure Calls vs HTTP APIs
• Contract first (proto file) • Content first (URLs, HTTP method, JSON)
• Contract is designed for humans
• Hides remoting complexity
• Content is designed for humans
• Emphasises HTTP
HTTP APIsRemote Procedure Calls
Performance
Developer productivity
Widest audience
Ease of getting started
34. Key features - Streaming
• gRPC uses HTTP/2 to enable streaming
35. Disadvantages – Limited browser support
• Browsers have great HTTP/2 support
• Browser JavaScript APIs haven’t caught up
• gRPC-web provides limited support for calling gRPC services
36. Disadvantages - Not human readable
• HTTP/2 and Protobuf are binary
protocols
• Additional tools required to
debug calls
BloomRPC
44. Blazor on client or server
https://...
DOM
Razor Components
.NET
WebAssembly
https...
DOM
.NET Core
SignalR
Blazor WebAssembly Blazor Server
Razor Components
.NET
.NET Core 3.0May 2020
45. Blazor on client or server
Blazor WebAssembly Blazor Server
.NET Core 3.0May 2020
46. Build your own pizza store UI with Blazor
https://aka.ms/blazorworkshop
55. Built for .NET
developers
Create custom ML models using C#
or F# without having to leave the
.NET ecosystem
Custom ML made
easy with AutoML
Visual Studio Model Builder
and CLI make it super easy to
build custom ML Models
Extended with
TensorFlow & more
Leverage other popular ML
frameworks (TensorFlow,
ONNX, and more)
56. dot.net/ml
Product recommendation
Recommend products based on purchase history
using a matrix factorization algorithm.
Sentiment analysis
Analyze the sentiment of customer reviews
using a binary classification algorithm.
Price prediction
Predict taxi fares based on distance traveled
etc. using a regression algorithm.
Customer segmentation
Identify groups of customers with similar
profiles using a clustering algorithm.
Spam detection
Flag text messages as spam using a binary
classification algorithm.
Image classification
Classify images (e.g. broccoli vs pizza) using
a TensorFlow deep learning algorithm.
Sales forecasting
Forecast future sales for products using a
regression algorithm.
GitHub labeler
Suggest the GitHub label for new issues
using a multi-class classification algorithm.
Fraud detection
Detect fraudulent credit card transactions
using a binary classification algorithm.
57.
58.
59. Supports Raspberry Pi
and other devices
You can now run .NET Core apps in
small places, including ASP.NET
Read sensor data
& write to displays
New APIs for GPIO pins that
enable using millions of IoT
peripherals
Works with
containers
Deploy apps directly onto
devices or with containers
66. • Web Forms, WCF Server and Windows Workflow remain
on .NET Framework 4.8 only. There are no plans to port
these.
• Recommendations
• ASP.NET Blazor for ASP.NET Web Forms (we will provide a migration guide)
• gRPC for WCF Server and Remoting (we will provide a migration guide)
• Open Source Core Workflow for Windows Workflow (WF):
https://github.com/UiPath/corewf
69. • .NET Core 3.1 LTS
• C# 8 with Nullable Reference TypesNew Development
• Update to .NET Core 3
• Single file publishingWindows Forms / WPF
• Look at Blazor
Web Forms
• Continue running on .NET Framework
• gRPC or CoreWCFWCF
71. .NET 5
INFRASTRUCTURE
.NET STANDARD
.NET – A unified platform
DESKTOP WEB CLOUD MOBILE GAMING IoT AI
WPF
Windows Forms
UWP
ASP.NET Xamarin UnityAzure ARM32
ARM64
ML.NET
.NET for
Apache Spark
72. • .NET Core 3.0 released
• .NET Core 3.1 = Long Term Support (LTS)
July 2019
.NET Core 3.0
RC
Sept 2019
.NET Core 3.0
Nov 2019
.NET Core 3.1
LTS
Nov 2020
.NET 5.0
Nov 2021
.NET 6.0
LTS
Nov 2022
.NET 7.0
Nov 2023
.NET 8.0
LTS
• .NET 5.0 release in November 2020
• Major releases every year, LTS for even numbered releases
• Predictable schedule, minor releases if needed
73. DESKTOP WEB CLOUD MOBILE GAMING IoT AI
.NET
Download .NET Core 3.1 Today!
visualstudio.com/downloads
dot.net/get-core3
Additional data points –
-C# moved from 7th to 5th in TIOBE Language Index 2020
-.NET Core 3 is fastest adopted version of .NET, ever
-dotnet org on GitHub has been top 3 highest velocity projects three years in a row as named by CNCF (see slide 13 for details)
Sources:
https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted
https://github.com/cncf/velocity/
https://octoverse.github.com/
https://www.techempower.com/benchmarks/#section=data-r18&hw=ph&test=plaintext
Today we’re going to show you how .NET can be used to build any type of app. We’re going to start with cloud development and microservices.
<CLICK TO NEXT SLIDE>
We’ve added Windows Desktop support with Windows Forms and WPF support. This brings the capabilities of .NET Core to these UI frameworks which millions of .NET developers are building on today. Particularly useful is the flexible deployment with side-by-side and self-contained EXEs so you don’t have to have .NET installed on the machine first anymore.
We also have some exiting new things for Web developers with Blazor, adding full-stack web development with C# and Razor, allowing you to build beautiful and responsive Single Page Apps without having to write JavaScript!
Additionally we have a ton of improvements for building better cloud native, scalable apps and microservices with ASP.NET and of course some exciting C# 8.0 language features.
<CLICK>
-There are alternative RPC frameworks, e.g. Thrift
-Developer community is unifying behind gRPC
-gRPC is run by CNCF. Microsoft contributing to CNCF
-Does not stand for Google RPC
-gRPC is not new, open sourced in 2015
-Union of two technologies, HTTP2 and Protocol Buffers
-Designed for modern apps, particularly microservices
Protocol Buffers serves three purposes:
-Language independent definition of Protobuf messages. Written in proto file that can be shared between apps
-Definition of services for use on server and client
-Binary format of messages. Small and fast, but not human readable
gRPC is an opination contract-first RPC framework
HTTP APIs focus on the shape and content of HTTP (contract optional)
proto files are designed for humans to write and read. Content is binary
HTTP APIs are the opposite: content is human readable. Optional schema is rather verbose
gRPC methods are designed to hide complexity of remoting
Call them like you would a method, no creating HTTP messages or JSON content
A key benefit of gRPC vs REST is small size of requests
-HTTP/2 is binary compared to text based HTTP1
-HTTP/2 supports header compression. Commonly occurring headers, e.g. content-type, are compressed to a few bits per request
-Protobuf is significantly smaller than JSON
JSON is a self describing format – characters are included to differentiate objects/arrays/strings/numbers
Protobuf requires the proto file to make sense of content
Simple comparison between JSON and Protobuf
Protobuf is 30% the size of JSON
Difference reduces to 50% with gzip
HTTP/2 multiplexing makes more efficient use of TCP connections
Multiplexing improves on HTTP1.1 pipelining
-Pipelining requires the order of requests and responses match
-A large image or slow API call may prevent faster requests from completing
HTTP/3 should improve this situation even more.
Code generation is at the core of gRPC
Code generation is driving by Protocol Buffer IDL
Example
-Simple server streaming call
-csproj references proto file in ProtoBuf item
-Grpc.Tools has targets to generate .NET types at design time
-Server is a base type that requires implementation
-Client is strongly typed, created with channel that specifies the server location
Proto files can be shared between servers, and languages.
gRPC is supported in every language
-Common set of interop tests
-gRPC on .NET Core is continuously tested against other implementations
HTTP/2 has excellent streaming support
gRPC uses HTTP/2 streaming to enable message streaming
Unary. Like REST. Single request, single reply
Server streaming is initiated with a request, returns a stream of responses. Example, subscribing to updates.
Client streaming is the opposite: stream requests, finish with response. Example: uploading data
Bi directional stream is streaming in both direction. Example: chat room
gRPC streaming is a really easy way to create realtime services.
Wow, gRPC is great, lets throw REST and JSON away
There are some drawbacks to gRPC
-Modern browsers have great support for browsing HTTP/2 websites
-But browser JavaScript APIs for making HTTP requests haven’t caught up
-JavaScript’s XMLHttpRequest and fetch do not provide low level access to HTTP/2 frames
-Not possible to build a gRPC client in the browser
Workaround today is gRPC-web
-Built by the gRPC team
-Provides limited support for calling some gRPC services over HTTP1
-A server proxy then translates between gRPC-web calls and normal HTTP/2 gRPC
-Does not support bi-directional streaming
HTTP/2 and Protobuf are small and fast
-But they’re not human readable
-Binary, and properly reading a gRPC message requires the proto file
Additional tools are required to debug gRPC calls
-Here I am reading a gRPC TCP packet in Wireshark. It has some support for gRPC
-It can recognize a gRPC packet from content-type headers
-It can see that this is a response for a the SayHello method
-gRPC message is still mostly binary
There are workarounds. Most gRPC services use protobuf, but JSON can be used during development
Clarify that we support ARM32/ARM64 (that’s for the Pi and friends) but also x64 for devices that need more horse power. This matches the IoT edge offering
We offer a new API, in this package: https://www.nuget.org/packages/System.Device.Gpio. Supports GPIO, PWM, SPI and I2C.
2014 – .NET Framework, .NET Core, Xamarin / Mono
Three different frameworks, hard to share code across them
2016 – Introduce .NET Standard - can write libraries that run on all the .NET’s.
While all .NET’s must implement the same API’s, their implementations are different. The Runtimes are different.
2019 – Introduce .NET 5 – Windows, Mac, Linux, Android, IOS all run .NET Core’s runtime
Same BCL used on all platforms, same runtime used on all platforms
Native code compilation on all platforms, by merging .NET Native and Mono AOT
JIT and AOT Runtime
.NET 5 is the next major version of the .NET Platform that brings technologies from .NET Framework, .NET Core and & Mono runtimes and frameworks together into one .NET platform.
.NET 5 will have one Base Class Library (BCL) that will contain APIs for building any type of application. All .NET workloads are supported with application frameworks including cross-platform web development with ASP.NET, iOS and Android mobile development with Xamarin, Windows Desktop, and cross-platform IoT.
.NET 5 will have both Just-in-Time (JIT) and Ahead-of-Time (AOT) compilation models for the multiple compute and device scenarios it must support. JIT has better performance for server and desktop workloads as well as development environments. AOT has better startup, a small footprint, and is required for mobile and IoT devices.
.NET 5 will also have one unified toolchain supported by new SDK project types, will have a flexible deployment model (Side-by-Side and self-contained EXEs) and continue .NET Core's superior performance for server & cloud workloads.
.NET 5 is the evolution of .NET Core, adding the best capabilities of Mono to provide support for small device footprints. .NET Core used the best parts of the .NET Framework as we built its initial release. .NET 5 takes the best of all of the learnings we have across our multiple implementations and brings them together into a single unified platform.
As we add more and more workloads to .NET Core, and continue to innovate and focus on modern platform capabilities, we are at a point where we will be providing only critical updates to .NET Framework. This means that applications running on .NET Framework will continue to run the same as they always have. However, this also means that any new development should be with .NET Core moving forward.
.NET is an entire software development platform that takes care of a lot of the heavy lifting for you when you want to build an application. Applications frameworks help you build the specific types of apps or workloads and enable you to literally build any app for any platform with any operating system. Each .NET workload shares a common infrastructure and base libraries ad .NET Standard. This means not only are your .NET skills portable, but your actual code is portable no matter what you’re building. This makes it easy to share libraries across the breadth of applications people build.
Additionally, there are a broad set of development tools that makes it really productive to write, debug, build and manage code bases.
See: www.dot.net