Kubernetes is designed to be an extensible system. But what is the vision for Kubernetes Extensibility? Do you know the difference between webhooks and cloud providers, or between CRI, CSI, and CNI? In this talk we will explore what extension points exist, how they have evolved, and how to use them to make the system do new and interesting things. We’ll give our vision for how they will probably evolve in the future, and talk about the sorts of things we expect the broader Kubernetes ecosystem to build with them.
Kubernetes has become the defacto standard as a platform for container orchestration. Its ease of extending and many integrations has paved the way for a wide variety of data science and research tooling to be built on top of it.
From all encompassing tools like Kubeflow that make it easy for researchers to build end-to-end Machine Learning pipelines to specific orchestration of analytics engines such as Spark; Kubernetes has made the deployment and management of these things easy. This presentation will showcase some of the larger research tools in the ecosystem and go into how Kubernetes has enabled this easy form of application management.
MuleSoft Manchester Meetup #3 slides 31st March 2020Ieva Navickaite
Francis Edwards from Saint-Gobain Building Distribution presented on design practices for accelerating API delivery using Anypoint Platform. He discussed how to integrate API design with development using RAML and how elements like title, version, and baseUri are used across different Anypoint tools. Venkata Nallapuneni from Rathbone Brothers then presented on DataWeave 2.0 and how it has improved and simplified data transformation compared to Mule Expression Language.
Effective Building your Platform with Kubernetes == Keep it Simple Wojciech Barczyński
Effective Kubernetes is a continuous deployment process that the team understands. Keep it Simple. Think twice before going for more complex solutions.
Source: https://github.com/wojciech12/talk_effective_kubernetes
Presented at Cloud Native Talks #2 (Online Meetup) - https://www.meetup.com/Cloud-Native-Kubernetes-Warsaw/events/257125529/
Language Server Protocol - Why the Hype?mikaelbarbero
The Language Server Protocol developed by Microsoft for Visual Studio Code is a language and IDE agnostic protocol which clearly separates language semantics from UI presentation. Language developers can implement the protocol and benefit from immediate support in all IDEs, while IDE developers, who implement the protocol get automatic support for all these languages without having to write any language-specific code. This session will let you learn more about the innards of the LSP. We will also have an overview of the current implementations in Eclipse, and outside Eclipse as well.
Learn from the dozens of large-scale deployments how to get the most out of your Kubernetes environment:
- Container images optimization
- Organizing namespaces
- Readiness and Liveness probes
- Resource requests and limits
- Failing with grace
- Mapping external services
- Upgrading clusters with zero downtime
Kubernetes is designed to be an extensible system. But what is the vision for Kubernetes Extensibility? Do you know the difference between webhooks and cloud providers, or between CRI, CSI, and CNI? In this talk we will explore what extension points exist, how they have evolved, and how to use them to make the system do new and interesting things. We’ll give our vision for how they will probably evolve in the future, and talk about the sorts of things we expect the broader Kubernetes ecosystem to build with them.
Kubernetes has become the defacto standard as a platform for container orchestration. Its ease of extending and many integrations has paved the way for a wide variety of data science and research tooling to be built on top of it.
From all encompassing tools like Kubeflow that make it easy for researchers to build end-to-end Machine Learning pipelines to specific orchestration of analytics engines such as Spark; Kubernetes has made the deployment and management of these things easy. This presentation will showcase some of the larger research tools in the ecosystem and go into how Kubernetes has enabled this easy form of application management.
MuleSoft Manchester Meetup #3 slides 31st March 2020Ieva Navickaite
Francis Edwards from Saint-Gobain Building Distribution presented on design practices for accelerating API delivery using Anypoint Platform. He discussed how to integrate API design with development using RAML and how elements like title, version, and baseUri are used across different Anypoint tools. Venkata Nallapuneni from Rathbone Brothers then presented on DataWeave 2.0 and how it has improved and simplified data transformation compared to Mule Expression Language.
Effective Building your Platform with Kubernetes == Keep it Simple Wojciech Barczyński
Effective Kubernetes is a continuous deployment process that the team understands. Keep it Simple. Think twice before going for more complex solutions.
Source: https://github.com/wojciech12/talk_effective_kubernetes
Presented at Cloud Native Talks #2 (Online Meetup) - https://www.meetup.com/Cloud-Native-Kubernetes-Warsaw/events/257125529/
Language Server Protocol - Why the Hype?mikaelbarbero
The Language Server Protocol developed by Microsoft for Visual Studio Code is a language and IDE agnostic protocol which clearly separates language semantics from UI presentation. Language developers can implement the protocol and benefit from immediate support in all IDEs, while IDE developers, who implement the protocol get automatic support for all these languages without having to write any language-specific code. This session will let you learn more about the innards of the LSP. We will also have an overview of the current implementations in Eclipse, and outside Eclipse as well.
Learn from the dozens of large-scale deployments how to get the most out of your Kubernetes environment:
- Container images optimization
- Organizing namespaces
- Readiness and Liveness probes
- Resource requests and limits
- Failing with grace
- Mapping external services
- Upgrading clusters with zero downtime
Cilium: Kernel Native Security & DDOS Mitigation for Microservices with BPFDocker, Inc.
We have introduced Cilium at DockerCon US 2017 this year. Cilium provides application-aware network connectivity, security, and load-balancing for containers. This talk will follow up on the introduction and deep dive into recent kernel developments that address two fundamental questions: How can I provide application-aware security and routing efficiently without overhead embedded into every service? How can container hosts protect themselves from internal and external DDoS attacks? The solutions include:
kproxy: a kernel-based socket proxy which allows for application-aware routing and security enforcement with minimal overhead.
XDP: A lightning-fast packet processing datapath using BPF. The technology is intended for DDoS mitigation, load-balancing, and forwarding.
This talk will deep dive into these exciting technologies and show how Cilium makes BPF and these kernel features available on Linux for your Docker containers.
Building kubectl plugins with Quarkus | DevNation Tech TalkRed Hat Developers
We all know how flexible Kubernetes extensions can be - Tekton and Knative are examples. But did you know it's also pretty easy to extend kubectl, the Kubernetes superstar CLI? In this session we see how a kubectl plugin is designed and then from scratch, we will build our own plugin using Quarkus. That will give us the opportunity to discover the command mode of Quarkus, rediscover how native compilation can create super fast binaries, and see how the Kubernetes-client extensions make it super easy to interact with a Kubernetes cluster.
An in depth overview of Kubernetes and it's various components.
NOTE: This is a fixed version of a previous presentation (a draft was uploaded with some errors)
Kubernetes is a container orchestrator platform, not the docker platform. It means we can switch to a different container solutions in the Kubernetes environment and the key point is the CRI, container runtime intface. We will talked about what is the CRI and how to use it in the Kubernetes world, we also introduce what is the OCI, the basic concept of the OCI, inclduing Runtime spec and Image spec.
Setting up CI/CD pipeline with Kubernetes and Kublr step-by-stepOleg Chunikhin
This document outlines the steps to set up a CI/CD pipeline with Kubernetes and Kublr. It describes using Kublr to automate the deployment and configuration of Kubernetes clusters. It then discusses setting up the necessary DevOps tools like Jenkins, Nexus, and monitoring within the Kubernetes environment to enable continuous integration and continuous delivery of applications. The general approach involves connecting these tools with a Git repository to build, test, and deploy code changes automatically through the pipeline to development and production clusters.
K8s in 3h - Kubernetes Fundamentals TrainingPiotr Perzyna
Kubernetes (K8s) is an open-source system for automating deployment, scaling, and management of containerized applications. This training helps you understand key concepts within 3 hours.
Orchestrating Microservices with Kubernetes Weaveworks
- Kubernetes Concepts
- Hands on: Using kubeadm to stand up a Kubernetes cluster
- Hands on: Using kubectl to make changes to running Kubernetes cluster
Kubernetes Architecture - beyond a black box - Part 2Hao H. Zhang
This continues the Kubernetes architecture deep dive series. (Part 1 see https://www.slideshare.net/harryzhang735/kubernetes-beyond-a-black-box-part-1)
In Part 2 I'm going to cover the following:
- Kubernetes's 3 most import design choices: Micro-service Choreography, Level-Triggered Control, Generalized Workload and Centralized Controller
- Default scheduler limitation and community's next step
- Interface to production environment
- Workload abstraction: strength and limitations
This concludes my work and knowledge sharing about Kubernetes.
This document provides an overview of Kubernetes concepts including architecture, fundamental objects like pods and services, and demonstrations. It begins with an agenda then covers Kubernetes architecture including the master node, worker nodes, and control loop. It describes core objects like pods, replica sets, deployments, services, and labels/selectors. The document demonstrates deploying and accessing the guestbook application using these objects. It concludes with asking for questions and describing goals for educational meetups on cloud native technologies.
Continuous Delivery the Hard Way with Kubernetes Weaveworks
The document discusses continuous delivery of software to Kubernetes using various tools. It proposes three architectures (V1, V2, V3) to connect version control, CI/CD systems, container registries, and Kubernetes. V3 introduces a "release manager" to decouple code versions from deployments, automate configuration updates, and allow rollbacks without pushing new code. The release manager watches for image changes, commits configuration updates, and controls deployments based on release policies for each environment.
Docker Platform Internals: Taking runtimes and image creation to the next lev...Docker, Inc.
In this session, we'll go into details about the latest developments around some of the components behind the core features of the Docker Platform. We'll cover the containerd runtime that was built to serve as an underlying daemon for Docker and Kubernetes, and BuildKit, a toolkit that builds on containerd to provide next-generation capabilities for building software with the help of containers. You will learn about the architecture and design choices of these projects, for example, the power of containerd's rich client library and BuildKit's frontend model that allows introducing new build languages or Dockerfile features. You can discover how you can use these projects directly and how they are being integrated into the Docker Platform.
KubeCon EU 2016: Kubernetes and the Potential for Higher Level InterfacesKubeAcademy
Kubernetes provides rock-solid APIs for building and running your distributed systems. Pods, Services and ReplicationControllers provide trustworthy and scalable abstractions that make solving real-world infrastructure problems simpler. But that doesn’t mean interacting with those low-level primitives will be the only option for developers and operators.
Sched Link: http://sched.co/67dA
Kubernetes and Bluemix introduction along with the sample demo application(Color Cluster) on IBM Bluemix Container Service(BCS). Also, some advanced features provided by IBM. Sample code for the repo is here, [Kuberbetes Bluemix Demo](https://github.com/mohan08p/KubernetesMeetup/tree/master/14th%20Oct%202017/ColorDemo)
Pluggable Infrastructure with CI/CD and DockerBob Killen
The docker cluster ecosystem is still young, and highly modular. This presentation covers some of the challenges we faced deciding on what infrastructure to deploy, and a few tips and tricks in making both applications and infrastructure easily adaptable.
An OpenShift Primer for Developers to get your Code into the Cloud (PTJUG)Eric D. Schabell
Session given at the PTJUG (Portugal JUG):
Whether you're a seasoned Java developer looking to start hacking on EE6 or you just wrote your first line of Ruby yesterday, the cloud is turning out to be the perfect environment for developing applications in just about any modern language or framework. There are plenty of clouds and platform-as-a-services to choose from, but where to start? Join us for an action-packed hour of power where we'll show you how to deploy an application written in the language of your choice - Java, Ruby, PHP, Perl or Python, with the framework of your choice - EE6, CDI, Seam, Spring, Zend, Cake, Rails, Sinatra, PerlDancer or Django to the OpenShift PaaS in just minutes. And without having to rewrite your app to get it to work the way the cloud provider thinks your app should work.
Check the command-line fu as we leverage Git to onboard apps onto OpenShift Express in seconds, while also making use of the web browser do the heavy-lifting of provisioning clusters, deploying, monitoring and auto-scaling apps in OpenShift Flex.
If you want to learn how the OpenShift PaaS and investing an hour of your time can change everything you thought you knew about developing applications in the cloud, this session is for you!
This document discusses Kubernetes and container orchestration. It begins with an introduction to containers and their advantages. It then introduces Kubernetes as an open source container orchestration system and discusses some of its key concepts like pods, replication controllers, services, labels, and persistent volumes. It also provides an overview of a sample application and Kubernetes lab for hands-on learning.
This document discusses CNI and the Linen CNI plugin. It begins with an introduction to CNI and how it allows plugins to configure network interfaces in containers. It then discusses the Linen CNI plugin, which is designed for overlay networks and uses Open vSwitch. It explains how Linen CNI works with Kubernetes and provides packet processing between nodes. The document also compares Linen CNI to other overlay networking solutions like OVN-Kubernetes.
Multiplatform shared codebase with Kotlin/Native - UA Mobile 2019UA Mobile
If you want to share the code between Android and iOS but you don't feel like doing C++/JNI, React Native, Flutter, you must try Kotlin/Native! In this presentation we will see how Kotlin/Native is different and in some aspects superior, and how easy it becomes to develop, debug and maintain a common codebase with JetBrains tools and without sacrificing runtime performance.
Multiplatform shared codebase with Kotlin/Native - UA Mobile 2019Eugene Kurko
f you want to share the code between Android and iOS but you don't feel like doing C++/JNI, React Native, Flutter, you must try Kotlin/Native! In this presentation we will see how Kotlin/Native is different and in some aspects superior, and how easy it becomes to develop, debug and maintain a common codebase with JetBrains tools and without sacrificing runtime performance.
Cilium: Kernel Native Security & DDOS Mitigation for Microservices with BPFDocker, Inc.
We have introduced Cilium at DockerCon US 2017 this year. Cilium provides application-aware network connectivity, security, and load-balancing for containers. This talk will follow up on the introduction and deep dive into recent kernel developments that address two fundamental questions: How can I provide application-aware security and routing efficiently without overhead embedded into every service? How can container hosts protect themselves from internal and external DDoS attacks? The solutions include:
kproxy: a kernel-based socket proxy which allows for application-aware routing and security enforcement with minimal overhead.
XDP: A lightning-fast packet processing datapath using BPF. The technology is intended for DDoS mitigation, load-balancing, and forwarding.
This talk will deep dive into these exciting technologies and show how Cilium makes BPF and these kernel features available on Linux for your Docker containers.
Building kubectl plugins with Quarkus | DevNation Tech TalkRed Hat Developers
We all know how flexible Kubernetes extensions can be - Tekton and Knative are examples. But did you know it's also pretty easy to extend kubectl, the Kubernetes superstar CLI? In this session we see how a kubectl plugin is designed and then from scratch, we will build our own plugin using Quarkus. That will give us the opportunity to discover the command mode of Quarkus, rediscover how native compilation can create super fast binaries, and see how the Kubernetes-client extensions make it super easy to interact with a Kubernetes cluster.
An in depth overview of Kubernetes and it's various components.
NOTE: This is a fixed version of a previous presentation (a draft was uploaded with some errors)
Kubernetes is a container orchestrator platform, not the docker platform. It means we can switch to a different container solutions in the Kubernetes environment and the key point is the CRI, container runtime intface. We will talked about what is the CRI and how to use it in the Kubernetes world, we also introduce what is the OCI, the basic concept of the OCI, inclduing Runtime spec and Image spec.
Setting up CI/CD pipeline with Kubernetes and Kublr step-by-stepOleg Chunikhin
This document outlines the steps to set up a CI/CD pipeline with Kubernetes and Kublr. It describes using Kublr to automate the deployment and configuration of Kubernetes clusters. It then discusses setting up the necessary DevOps tools like Jenkins, Nexus, and monitoring within the Kubernetes environment to enable continuous integration and continuous delivery of applications. The general approach involves connecting these tools with a Git repository to build, test, and deploy code changes automatically through the pipeline to development and production clusters.
K8s in 3h - Kubernetes Fundamentals TrainingPiotr Perzyna
Kubernetes (K8s) is an open-source system for automating deployment, scaling, and management of containerized applications. This training helps you understand key concepts within 3 hours.
Orchestrating Microservices with Kubernetes Weaveworks
- Kubernetes Concepts
- Hands on: Using kubeadm to stand up a Kubernetes cluster
- Hands on: Using kubectl to make changes to running Kubernetes cluster
Kubernetes Architecture - beyond a black box - Part 2Hao H. Zhang
This continues the Kubernetes architecture deep dive series. (Part 1 see https://www.slideshare.net/harryzhang735/kubernetes-beyond-a-black-box-part-1)
In Part 2 I'm going to cover the following:
- Kubernetes's 3 most import design choices: Micro-service Choreography, Level-Triggered Control, Generalized Workload and Centralized Controller
- Default scheduler limitation and community's next step
- Interface to production environment
- Workload abstraction: strength and limitations
This concludes my work and knowledge sharing about Kubernetes.
This document provides an overview of Kubernetes concepts including architecture, fundamental objects like pods and services, and demonstrations. It begins with an agenda then covers Kubernetes architecture including the master node, worker nodes, and control loop. It describes core objects like pods, replica sets, deployments, services, and labels/selectors. The document demonstrates deploying and accessing the guestbook application using these objects. It concludes with asking for questions and describing goals for educational meetups on cloud native technologies.
Continuous Delivery the Hard Way with Kubernetes Weaveworks
The document discusses continuous delivery of software to Kubernetes using various tools. It proposes three architectures (V1, V2, V3) to connect version control, CI/CD systems, container registries, and Kubernetes. V3 introduces a "release manager" to decouple code versions from deployments, automate configuration updates, and allow rollbacks without pushing new code. The release manager watches for image changes, commits configuration updates, and controls deployments based on release policies for each environment.
Docker Platform Internals: Taking runtimes and image creation to the next lev...Docker, Inc.
In this session, we'll go into details about the latest developments around some of the components behind the core features of the Docker Platform. We'll cover the containerd runtime that was built to serve as an underlying daemon for Docker and Kubernetes, and BuildKit, a toolkit that builds on containerd to provide next-generation capabilities for building software with the help of containers. You will learn about the architecture and design choices of these projects, for example, the power of containerd's rich client library and BuildKit's frontend model that allows introducing new build languages or Dockerfile features. You can discover how you can use these projects directly and how they are being integrated into the Docker Platform.
KubeCon EU 2016: Kubernetes and the Potential for Higher Level InterfacesKubeAcademy
Kubernetes provides rock-solid APIs for building and running your distributed systems. Pods, Services and ReplicationControllers provide trustworthy and scalable abstractions that make solving real-world infrastructure problems simpler. But that doesn’t mean interacting with those low-level primitives will be the only option for developers and operators.
Sched Link: http://sched.co/67dA
Kubernetes and Bluemix introduction along with the sample demo application(Color Cluster) on IBM Bluemix Container Service(BCS). Also, some advanced features provided by IBM. Sample code for the repo is here, [Kuberbetes Bluemix Demo](https://github.com/mohan08p/KubernetesMeetup/tree/master/14th%20Oct%202017/ColorDemo)
Pluggable Infrastructure with CI/CD and DockerBob Killen
The docker cluster ecosystem is still young, and highly modular. This presentation covers some of the challenges we faced deciding on what infrastructure to deploy, and a few tips and tricks in making both applications and infrastructure easily adaptable.
An OpenShift Primer for Developers to get your Code into the Cloud (PTJUG)Eric D. Schabell
Session given at the PTJUG (Portugal JUG):
Whether you're a seasoned Java developer looking to start hacking on EE6 or you just wrote your first line of Ruby yesterday, the cloud is turning out to be the perfect environment for developing applications in just about any modern language or framework. There are plenty of clouds and platform-as-a-services to choose from, but where to start? Join us for an action-packed hour of power where we'll show you how to deploy an application written in the language of your choice - Java, Ruby, PHP, Perl or Python, with the framework of your choice - EE6, CDI, Seam, Spring, Zend, Cake, Rails, Sinatra, PerlDancer or Django to the OpenShift PaaS in just minutes. And without having to rewrite your app to get it to work the way the cloud provider thinks your app should work.
Check the command-line fu as we leverage Git to onboard apps onto OpenShift Express in seconds, while also making use of the web browser do the heavy-lifting of provisioning clusters, deploying, monitoring and auto-scaling apps in OpenShift Flex.
If you want to learn how the OpenShift PaaS and investing an hour of your time can change everything you thought you knew about developing applications in the cloud, this session is for you!
This document discusses Kubernetes and container orchestration. It begins with an introduction to containers and their advantages. It then introduces Kubernetes as an open source container orchestration system and discusses some of its key concepts like pods, replication controllers, services, labels, and persistent volumes. It also provides an overview of a sample application and Kubernetes lab for hands-on learning.
This document discusses CNI and the Linen CNI plugin. It begins with an introduction to CNI and how it allows plugins to configure network interfaces in containers. It then discusses the Linen CNI plugin, which is designed for overlay networks and uses Open vSwitch. It explains how Linen CNI works with Kubernetes and provides packet processing between nodes. The document also compares Linen CNI to other overlay networking solutions like OVN-Kubernetes.
Multiplatform shared codebase with Kotlin/Native - UA Mobile 2019UA Mobile
If you want to share the code between Android and iOS but you don't feel like doing C++/JNI, React Native, Flutter, you must try Kotlin/Native! In this presentation we will see how Kotlin/Native is different and in some aspects superior, and how easy it becomes to develop, debug and maintain a common codebase with JetBrains tools and without sacrificing runtime performance.
Multiplatform shared codebase with Kotlin/Native - UA Mobile 2019Eugene Kurko
f you want to share the code between Android and iOS but you don't feel like doing C++/JNI, React Native, Flutter, you must try Kotlin/Native! In this presentation we will see how Kotlin/Native is different and in some aspects superior, and how easy it becomes to develop, debug and maintain a common codebase with JetBrains tools and without sacrificing runtime performance.
Kotlin is a statically typed programming language that runs on the JVM and is fully interoperable with Java. It aims to combine object-oriented and functional programming in a concise syntax that reduces boilerplate code. Kotlin was developed by JetBrains in 2010 and became an officially supported language for Android development by Google in 2017. It features improvements like type inference, data classes, default function parameters, null safety checks, and higher-order functions that allow developers to write safer, more concise code compared to Java.
Continuous Delivery the hard way with KubernetesLuke Marsden
This talk shows three increasingly advanced levels of continuous delivery with Kubernetes and GitLab (as an example), arguing for a continuous delivery architecture which has an explicit _Release Manager_ component. We then propose Flux, the open source project which powers the _Deploy_ feature of Weave Cloud, as an implementation of that idea. This approach is the precursor to GitOps.
Beachhead implements new opcode on CLR JITKouji Matsui
This document summarizes Kouji Matsui's presentation on adding a custom IL opcode to the .NET Core Common Language Runtime (CLR). The presentation covers building CoreCLR from source, declaring a new "customcode" opcode, implementing the JIT helper function and interpreter support, and verifying it works by inserting the opcode into a sample assembly using ilasm. The goal is to understand CoreCLR internals by adding a no-op opcode that outputs a debug string when executed.
Continuous Delivery the Hard Way with Kubernetes Weaveworks
How do you version control your deployment config + automate the delivery of your software through a CI/CD pipeline?
We will cover open source tools that facilitate:
• Simultaneously updating configuration and performing releases to Kubernetes
• Rolling back and pinning releases
• Having different release policies to different environments
Read the blog: https://www.weave.works/blog/continuous-delivery-the-hard-way
Visit Weave Cloud: https://www.weave.works/product/cloud/
For more free talks, join our Weave Online User Group: https://www.meetup.com/Weave-User-Group/
2#Kotlin programming tutorials(data types and hello world)Naveen Davis
Kotlin is a statically typed programming language that runs on the Java Virtual Machine and can also compile to JavaScript. It was announced by Google in 2017 as an officially supported language for Android development alongside Java and C++. The document provides an introduction to Kotlin and covers topics like data types, variables, arrays, strings, and the difference between val and var. It also includes a "Hello World" example program written in Kotlin.
This document provides an overview of Kubernetes 101. It begins with asking why Kubernetes is needed and provides a brief history of the project. It describes containers and container orchestration tools. It then covers the main components of Kubernetes architecture including pods, replica sets, deployments, services, and ingress. It provides examples of common Kubernetes manifest files and discusses basic Kubernetes primitives. It concludes with discussing DevOps practices after adopting Kubernetes and potential next steps to learn more advanced Kubernetes topics.
Mono 3.2 includes support for .NET 4.5, C# 5, and improvements to the SGen garbage collector. Major work-in-progress projects include PlayScript, a language like ActionScript for games, and CppSharp for improved C++ interop. Future work may allow inline assembly in C# and focus on community priorities identified in tomorrow's brainstorming session.
The document discusses containerizing MPI workloads using Docker and QNIBTerminal. It provides an overview of Docker, describes the QNIBTerminal testbed which runs an HPCG benchmark on multiple Linux distributions within Docker containers, and presents results showing a low performance overhead for containerized workloads compared to bare metal. Future work is discussed around optimizing containers for HPC and benchmarking real-world applications.
.NET Core is a cross-platform and open source implementation of .NET. It uses a new cross-platform runtime called CoreCLR and a new compiler platform called Roslyn. .NET Core allows developers to use C# and F# to write web applications like ASP.NET Core, mobile apps, IoT apps and more. It also introduces a new cross-platform command line interface called dotnet and supports running applications in Linux and Windows containers with Docker.
The document discusses the .NET Framework, including its architecture, components like the Common Language Runtime (CLR) and class libraries, advantages over other technologies like Java, and supported programming languages. The CLR handles tasks like memory management, security, and compilation to native code. Assemblies are fundamental deployment units. The .NET Framework provides a complete environment for developing various application types on Windows and other platforms.
Kubernetes buildpacks - from a source code to the running OCI container with ...PROIDEA
Kubernetes nowadays quickly outgrows Cloud Foundry. People even say containers are eating the software world. From the operator perspective the change is very much appreciated, but on the other hand there is a group which may have lost a very useful feature - a single click to run source, so called 'cf push'.
Can't we do the same in Kubernetes? Nothing could be more wrong! In this presentation Adam will show how this kind of tool can be implemented - from the source code packaging, through running the temporary builder in the and using OCI buildpacks.io pack to create resulting image and finally pushing it to the docker repository, running in the Kubernetes and exposing to the world.
Slides about Kotlin 1.1 presented on The Developers Conference Florianópolis 2017.
http://www.thedevelopersconference.com.br/tdc/2017/florianopolis/trilha-java
TDC2017 | Florianopolis - Trilha DevOps How we figured out we had a SRE team ...tdc-globalcode
Kotlin 1.1 introduces several new features including support for JavaScript targeting which is no longer experimental, coroutines which enable asynchronous programming, improved Spring support with new plugins, type aliases, bound callable references, and various other improvements to lambdas, properties, and the standard library. Kotlin 1.1.1 enables faster Gradle compilation and 1.1.2 requires JDK 8 to run the Kotlin compiler. The presentation discusses these new features and capabilities in Kotlin 1.1.
Kotlin's coroutines are more powerful than TypeScript's async/await for asynchronous programming. Coroutines are more general and can be used with other patterns besides just asynchronous code. In KotlinJS, coroutines work easily with Promises. They allow suspending functions without needing to explicitly "await", and can be applied to other patterns beyond just async code. Kotlin's coroutines are therefore superior to TypeScript's async/await for asynchronous programming in JavaScript.
Why to Choose Kotlin in 2023 to Build Mobile Apps Faster?9 series
We have laid down solid cases for Kotlin to choose the one that best suits your requirements and helps you build powerful Mobile apps faster. https://bit.ly/3Yw9OE9
Compose is a Kotlin library for building user interfaces across platforms like Android, Desktop, and Web. It provides a declarative programming model that allows describing UI as composable functions of pure data. The Compose compiler plugin handles calling these functions and managing the underlying UI component tree efficiently as data changes over time. Compose uses techniques like positional memoization and gap buffers to optimize caching of UI nodes and state for each call site in a composable function. This allows Compose to rebuild the UI incrementally based on changes in input data.
The document discusses various Kotlin language features and how they are compiled down to bytecode. It explains concepts like lowering, de-sugaring, and decompiling Kotlin programs. Specific language features summarized include free functions, nested functions, extension methods, data classes, object declarations, companion objects, and lambdas with receivers. The document shows how each feature compiles by decompiling example Kotlin code.
TypeScript has a larger and more established community compared to KotlinJS. While Kotlin's coroutines are more powerful than TypeScript's async/await, JSX is simpler than Kotlin's React DSL. TypeScript also has a more advanced type system with features like union, intersection and mapped types. However, Kotlin has more elegant syntax with expressions like when and if being expressions. Overall, both languages are good but TypeScript is better suited as a JavaScript superset while Kotlin shines in its multiplatform capabilities.
The document provides 10 lessons learned from the 1990s about software development:
1. Draw diagrams to design systems at different levels of abstraction.
2. Conduct design reviews focused on algorithms and patterns, not just syntax.
3. Prioritize stable frameworks and tools over constantly changing options.
4. Develop internal libraries and tools instead of solely relying on external dependencies.
5. Learn all aspects of testing, not just unit tests, and the role of testers.
6. Master development tools and optimize workflows through shortcuts and automation.
7. Focus on fundamentals like performance, data structures, and asynchronous programming.
8. Take responsibility for work and focus on principles over blindly following process.
The document discusses how the Kotlin compiler fakes or lies about certain Kotlin language features by decompiling the bytecode produced by the Kotlin compiler. It provides examples of how free functions, nested functions, primary constructors, extension methods, destructuring, object declarations, companion objects, enumerations, delegated properties, lambdas with receivers, and more are implemented under the hood by the compiler through bytecode tricks and deception. The document is intended to look under the hood of the Kotlin compiler and Java bytecode to understand how certain Kotlin features are implemented that don't have a direct mapping to Java.
The Kotlin compiler provides many features of Kotlin that do not exist natively in the JVM by generating bytecode that emulates these features. It uses various techniques like generating additional classes and methods, passing implicit parameters, and implementing functional interfaces to achieve this. The summary decompiles some Kotlin code examples to Java bytecode to illustrate how specific Kotlin features are implemented under the hood.
Generics On The JVM (What you don't know will hurt you)Garth Gilmour
Talk delivered to the London Kotlin Users Group. Covering how generics is implemented on the JVM and the different approaches taken by Java and Kotlin to co/contra variance and the lack of reified types.
Using Kotlin, to Create Kotlin,to Teach Kotlin,in SpaceGarth Gilmour
Talk delivered at the Kotliners 2020 conference. Covering how Instil used the Kotlin Space DSL to automatically populate Space instances used in coding workshops.
1) The document discusses whether software engineers can be considered professionals by examining the traditional definitions of a profession, which include belonging to a professional culture, having apprenticeships and lifelong careers, and following a code of conduct.
2) It reviews software engineering against these criteria and finds it lacking in some areas such as not having a strong professional culture or union.
3) The document also questions whether professionalism necessarily leads to competence, success, or growth in the field, providing some examples and arguments on both sides of this issue. It concludes that while ethics are important, professional status may not be critical for software engineering currently.
Social Distancing is not Behaving DistantlyGarth Gilmour
This document discusses strategies for effectively delivering training remotely during the COVID-19 pandemic. It outlines lessons learned from initial attempts at virtual training, including that it is difficult to engage students and maintain focus without in-person interaction. It recommends adopting a combined approach using multiple instructors, flexible scheduling of material, and specialized online tools to help facilitate collaborative learning and make remote training feel more personal.
Transitioning Android Teams Into KotlinGarth Gilmour
Talk delivered with Eamonn Boyle at GOTO Copenhagen in 2019. Covering how best to move from delivering Android projects in Java to writing the code in Kotlin.
Simpler and Safer Java Types (via the Vavr and Lambda Libraries)Garth Gilmour
This document provides an overview of functional programming concepts in Java using the Vavr and Lambda libraries. It begins with an introduction to the libraries and examples of common FP data structures and patterns like currying, tuples, Either, and pattern matching. It then demonstrates examples of collections, grouping, filtering and combining data using the Vavr library. The document aims to showcase how these libraries can provide cleaner FP abstractions compared to Java's built-in Streams API.
This document provides an overview of a Domain Driven Design training session held in Belfast in February 2019 by Instil Software. It discusses the philosophy of DDD and how it relates to bounded contexts and language games based on the work of philosopher Ludwig Wittgenstein. Key points covered include Wittgenstein's view that language is used within language games and bounded contexts, and that the meaning of words depends on their use rather than having absolute meanings. It also discusses how this relates to DDD and the importance of understanding the context in which terms are being used.
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
Most important New features of Oracle 23c for DBAs and Developers. You can get more idea from my youtube channel video from https://youtu.be/XvL5WtaC20A
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
The Key to Digital Success_ A Comprehensive Guide to Continuous Testing Integ...kalichargn70th171
In today's business landscape, digital integration is ubiquitous, demanding swift innovation as a necessity rather than a luxury. In a fiercely competitive market with heightened customer expectations, the timely launch of flawless digital products is crucial for both acquisition and retention—any delay risks ceding market share to competitors.
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
Malibou Pitch Deck For Its €3M Seed Roundsjcobrien
French start-up Malibou raised a €3 million Seed Round to develop its payroll and human resources
management platform for VSEs and SMEs. The financing round was led by investors Breega, Y Combinator, and FCVC.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
How Can Hiring A Mobile App Development Company Help Your Business Grow?ToXSL Technologies
ToXSL Technologies is an award-winning Mobile App Development Company in Dubai that helps businesses reshape their digital possibilities with custom app services. As a top app development company in Dubai, we offer highly engaging iOS & Android app solutions. https://rb.gy/necdnt
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
5. We held a workshop at the conference
• React Web App with Kotlin on
Server & Browser
About Instil
6. Excellent interoperability
• Call legacy Java code easily
• Make calls into Kotlin from Java
Really clear, yet concise syntax
• Reduces your codebase by 1/3+
Beloved by frameworks
• First class language on Android
• Mainstream language for Spring via
the Spring Initializr and Spring Fu
• New language for the Gradle DSL
• Kotlin specific frameworks emerging
• Notably Arrow and Ktor
Why Kotlin? Null Safety
String Templates
Default parameters
Extensions
Free Functions
Coroutines
Single Expression
Functions
Reified generics
Data classes and
Properties
Type Inference
Smart Casts
Operator
overloading
8. Java is a legacy language!
But in Java 11…
Kotlin has it today!!
Scala had it
years ago!!
No one gives
a **** about
modules!!
9. Kotlin was originally for the desktop and server
• As JetBrains own internal language
Then it exploded amongst the Android community
• This is still where it is most commonly found
Now its going further
• Kotlin Native builds apps to run outside the VM
• Kotlin JS is transpiled to run inside the browser
Kotlin On Other Platforms
10. Let the buyer beware!
• Everything you see is the
result of my own hacking
• I am very much still in the
learning stages myself…
A Warning…
12. Kotlin Native compiles Kotlin code to native binaries
• It produces executables that run without a virtual machine
The binary output is not portable, but the source is
• The compiler can compile the same source to multiple outputs
• The source can be placed into a multiplatform project
Introducing Kotlin Native
Kotlin Native
Compiler
LLVM Source LLVM
IR
Native
Binary
13. Supported platforms include,
• iOS (arm32, arm64, emulator x86_64)
• MacOS (x86_64)
• Android (arm32, arm64)
• Windows (mingw x86_64)
• Linux (x86_64, arm32, MIPS, MIPS little endian)
• WebAssembly (wasm32)
There is interop with C, Objective-C and Swift
• Kotlin code can call into any of these and vice versa
• Tools like ‘cinterop’ generate Kotlin declarations
based on C declarations found in header files
Introducing Kotlin Native
14. Common things such as Kotlin.io aren’t available
You can use POSIX and interop to achieve functionality or
use other multiplatform libraries
Introducing Kotlin Native
import kotlinx.cinterop.*
import platform.posix.*
import kotlinx.io.*
17. From the main thread we wish to start two Pthreads
• With the names ‘Thread No1’ and ‘Thread No2’
• This can be accomplished via ‘pthread_create’
Each thread will print out twenty messages
• In turn each message will be divided into three parts
We want the parts of each message to be atomic
• We do this by creating a mutex and passing it to the threads
• Each thread will:
• Acquire the mutex via ‘pthread_mutex_lock’
• Print the three parts of the message and releases it
• Release the mutex via ‘pthread_mutex_unlock’
The main thread will waits for the Pthreads
• This can be accomplished via ‘pthread_join’
A Demo of Pthreads
18. A Demo of Pthreads
Pthread Thread No1 message 1 part A
Pthread Thread No1 message 1 part B
Pthread Thread No1 message 1 part C
Pthread Thread No2 message 1 part A
Pthread Thread No2 message 1 part B
Pthread Thread No2 message 1 part C
Pthread Thread No1 message 2 part A
Pthread Thread No1 message 2 part B
Pthread Thread No1 message 2 part C
Pthread Thread No2 message 2 part A
Pthread Thread No2 message 2 part B
Pthread Thread No2 message 2 part C
Pthread Thread No1 message 3 part A
Pthread Thread No1 message 3 part B
Pthread Thread No1 message 3 part C
Pthread Thread No2 message 3 part A
Pthread Thread No2 message 3 part B
Pthread Thread No2 message 3 part C
...
...
…
Thread 1 holding mutex
Thread 2 holding mutex
Thread 1 holding mutex
Thread 2 holding mutex
Thread 1 holding mutex
Thread 2 holding mutex
29. Comparing Signatures for ‘pthread_create’
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)(void*),
void *arg);
public fun pthread_create(
arg0: CValuesRef<pthread_tVar>?,
arg1: CValuesRef<pthread_attr_t>?,
arg2: Cpointer<CFunction<(COpaquePointer?) -> COpaquePointer? >>?,
arg3: CValuesRef<*>?
): kotlin.Int
30. Comparing Signatures for ‘pthread_join’
int pthread_join(pthread_t thread,
void **retval);
public fun pthread_join(
arg0: pthread_t?,
arg1: CValuesRef<COpaquePointerVar>?
): kotlin.Int
31. Comparing Signatures for Mutex functions
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
public fun pthread_mutex_init(
arg0: CValuesRef<pthread_mutex_t >?,
arg1: CValuesRef<pthread_mutexattr_t >?
): kotlin.Int
public fun pthread_mutex_destroy(
arg0: CValuesRef<pthread_mutex_t>?
): kotlin.Int
32. The ‘cinterop’ tool generates Kotlin types from C types
• For structures the Kotlin name is the same as the C name
• For other types (e.g. opaque types) it is ‘${type}Var’
A void pointer is represented by the ‘COpaquePointer’ type
• An in-memory instance is represented by ‘COpaquePointerVar’
Pointers are represented in two ways:
• For variables use ‘CPointer<T>’ and ‘CPointerVar<T>’
• For parameters use ‘CValuesRef<T>’
What Have We Learned
34. Memory is allocated via ‘alloc’ functions
• There are versions for single types, arrays, pointers etc…
The memory allocated must be freed
• This can be managed for you via ‘memScoped { … }’
Null in Kotlin is translated into NULL in C
• I.e. the address denoted by zero where nothing lives
• NB Pthreads uses NULL to mean ‘go with the defaults’
Explaining the Demo Code
val mutex = alloc<pthread_mutex_t>()
pthread_mutex_init(mutex.ptr,null)
val threadHandle1 = alloc<pthread_tVar>()
val threadHandle2 = alloc<pthread_tVar>()
35. Kotlin strings are interoperable with C Strings
• The compiler converts between Strings and ‘const char *’
Manual conversion methods are available
• Calling ‘cstr’ on a String returns ‘CValuesRef<ByteVar>’
• You can call ‘toKString’ on a ‘CPointer<ByteVar>’
The ‘StableRef’ type is used to pass values through C
• This typically happens when you are writing a function in Kotlin
which will be called at a later date from C with cached data
• The Pthreads library is a good example of where this is useful
Explaining the Demo Code
val data1 = StableRef.create("Thread No1".cstr.ptr to mutex)
val data2 = StableRef.create("Thread No2".cstr.ptr to mutex)
36. When working with generated types
• Use ‘ptr’ to get the address in memory of a value
• Use ‘value’ to get the value from an address in memory
Standard Kotlin functions can be used as C callbacks
• As long as you convert the reference via ‘staticCFunction’
• Within the function you must call ‘initRuntimeIfNeeded()’
Explaining the Demo Code
pthread_create(threadHandle1.ptr,
attrs,
staticCFunction(::foobar),
data1.asCPointer())
37. In the code below we:
• Convert the opaque pointer to a StableRef of a Pair of values
• Convert the first value in the pair from a byte pointer to a String
• Specify default values for either item if it is missing
• Run the job of work to be done asynchronously
Explaining the Demo Code
val data = input?.asStableRef<Pair<CPointer<ByteVar>, pthread_mutex_t>>()
val name = data?.get()?.first?.toKString() ?: "No Name”
val dummy = alloc<pthread_mutex_t>()
val mutex = data?.get()?.second ?: dummy
for (x in 1..20) {
doWork(mutex, name, x)
}
38. Let Us Return To Normality
Let’s return to the normal world of sane people…
39. Kotlin Native has its own concurrency model
• Possible as JetBrains now has control of the underlying runtime
The main abstraction is a ‘Worker’
• Workers are similar to Actors in frameworks like Akka
You pass data and jobs to a worker via its ‘execute’ method
• The producer lambda returns a graph of objects whose
ownership will now be transferred to the target worker
• The calling thread won’t be able to access those objects
The Kotlin Native Concurrency Model
fun <T1, T2> execute(mode: TransferMode,
producer: () -> T1,
job: (T1) -> T2): Future<T2>
40. Objects in Kotlin Native can be frozen
• This is an operation that is performed at runtime
• All objects in a graph are marked as immutable
• Any writes result in an ‘InvalidMutabilityException’
Frozen objects can safely be shared between Workers
• Kotlin Native does not allow Workers to share mutable state
There are multiple ways to freeze an object:
• Singleton objects and enums are automatically frozen
• Arbitrary objects can be frozen via the ‘freeze’ method
• Global variables can be marked with ‘SharedImmutable’
Global variables can also be marked with ‘@ThreadLocal’
• In which case each Worker gets its own copy of the data
The Kotlin Native Concurrency Model