vJUG24 - Spring Boot and Kotlin, a match made in HeavenNicolas Fränkel
This document discusses how Spring Boot and Kotlin are a good match. It highlights how Spring Boot allows for convention over configuration and out-of-the-box features. It also summarizes some of Kotlin's main features like being functionally and object-oriented, statically typed, null safety, and Java compatibility. Extension functions are described as a killer feature that allow adding new methods on existing types. The document provides a basic "Hello World" Kotlin example and discusses using Kotlin with Spring Web and reactive Spring.
Rockstar Night - Spring, migrating to functional configurationNicolas Fränkel
In the latest years, there has been some push-back against frameworks, and more specifically annotations: some call them magic. Obviously, they make understanding the flow of the application harder.
Spring and Spring Boot latest versions go along this trend, by offering an additional way to configure beans with explicit code instead of annotations.
It's called functional, because it moves configuration from objects to behavior.
This talk aims to demo a step-by-step process to achieve that.
JDK.io - Spring and Kotlin, a match made in HeavenNicolas Fränkel
Despite being quite recent, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!
On the other hand, you're still using Java, with all its ceremony regarding code... Wouldn't it be great if we could pair Spring Boot with a powerful yet simple language?
In this talk, I'll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.
Morning at Lohika - Spring Boot Kotlin, a match made in HeavenNicolas Fränkel
The document discusses how Kotlin and Spring Boot are well integrated for developing applications. It provides an overview of Kotlin features like null safety and extensions, and how these improve on Java. It also discusses how Spring Boot works well with Kotlin's conventions. The document then shares details of a project to migrate a blog from XML to Markdown files using Kotlin and Spring Boot features like expression body methods and properties.
Odessa JUG - Spring Boot & Kotlin, a match made in HeavenNicolas Fränkel
Nicolas Frankel presents on the match between Spring Boot and Kotlin. He discusses why Spring Boot is useful for convention over configuration and out-of-the-box features. Kotlin is highlighted as being open source, compiling to JVM bytecode and JavaScript, with null safety and other features. Extension methods and properties are described as killer features that allow adding methods to existing types. The presentation concludes by noting the functional capabilities of Spring Web 5 with Kotlin.
Despite being quite “new”, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!
On the other hand, you’re still using Java, with all its ceremony regarding code… Wouldn’t it be great if we could pair Spring Boot with a powerful yet simple language?
In this talk, I’ll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.
JavaCro - Spring Boot and Kotlin, a match made in heavenNicolas Fränkel
Despite being quite “new”, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!On the other hand, you’re still using Java, with all its ceremony regarding code… Wouldn’t it be great if we could pair Spring Boot with a powerful yet simple language?In this talk, I’ll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.
Learn how to build Functional Reactive Applications with Elm, Node.js and Inf...J On The Beach
Developers aim to write responsive, scalable, fault tolerant, reactive applications to can handle the business needs of the modern web applications without hiccups. This talk shows you how to do just that! And to add a twist, we will do it in a (pure) functional style.
Node.js is a very popular framework for developing asynchronous, event-driven, reactive applications. Infinispan, an in-memory distributed data grid designed for fast, scalable, elastic access to large volumes of data, has recently gained compatibility with the Node.js ecosystem enabling reactive applications to use it as persistence layer. When combined with Elm, a functional programming language for declaratively creating reactive web applications, these technologies offer a great platform for working with highly responsive, data-heavy applications seamlessly. In this live-coding talk, we will demonstrate how to use these technologies to build a reactive web application composed of an Elm frontend, a Node.js microservice layer and a scalable, fault tolerant Infinispan data grid for persistence.
vJUG24 - Spring Boot and Kotlin, a match made in HeavenNicolas Fränkel
This document discusses how Spring Boot and Kotlin are a good match. It highlights how Spring Boot allows for convention over configuration and out-of-the-box features. It also summarizes some of Kotlin's main features like being functionally and object-oriented, statically typed, null safety, and Java compatibility. Extension functions are described as a killer feature that allow adding new methods on existing types. The document provides a basic "Hello World" Kotlin example and discusses using Kotlin with Spring Web and reactive Spring.
Rockstar Night - Spring, migrating to functional configurationNicolas Fränkel
In the latest years, there has been some push-back against frameworks, and more specifically annotations: some call them magic. Obviously, they make understanding the flow of the application harder.
Spring and Spring Boot latest versions go along this trend, by offering an additional way to configure beans with explicit code instead of annotations.
It's called functional, because it moves configuration from objects to behavior.
This talk aims to demo a step-by-step process to achieve that.
JDK.io - Spring and Kotlin, a match made in HeavenNicolas Fränkel
Despite being quite recent, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!
On the other hand, you're still using Java, with all its ceremony regarding code... Wouldn't it be great if we could pair Spring Boot with a powerful yet simple language?
In this talk, I'll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.
Morning at Lohika - Spring Boot Kotlin, a match made in HeavenNicolas Fränkel
The document discusses how Kotlin and Spring Boot are well integrated for developing applications. It provides an overview of Kotlin features like null safety and extensions, and how these improve on Java. It also discusses how Spring Boot works well with Kotlin's conventions. The document then shares details of a project to migrate a blog from XML to Markdown files using Kotlin and Spring Boot features like expression body methods and properties.
Odessa JUG - Spring Boot & Kotlin, a match made in HeavenNicolas Fränkel
Nicolas Frankel presents on the match between Spring Boot and Kotlin. He discusses why Spring Boot is useful for convention over configuration and out-of-the-box features. Kotlin is highlighted as being open source, compiling to JVM bytecode and JavaScript, with null safety and other features. Extension methods and properties are described as killer features that allow adding methods to existing types. The presentation concludes by noting the functional capabilities of Spring Web 5 with Kotlin.
Despite being quite “new”, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!
On the other hand, you’re still using Java, with all its ceremony regarding code… Wouldn’t it be great if we could pair Spring Boot with a powerful yet simple language?
In this talk, I’ll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.
JavaCro - Spring Boot and Kotlin, a match made in heavenNicolas Fränkel
Despite being quite “new”, Spring Boot has seen a spectacular start as an amazing kickstarter for Spring-based application. You can now start your project in a matter of minutes, not days!On the other hand, you’re still using Java, with all its ceremony regarding code… Wouldn’t it be great if we could pair Spring Boot with a powerful yet simple language?In this talk, I’ll live code a Spring Boot application using Kotlin, the friendly language provided by JetBrains. Come discover how you can now cut through all the red tape and finally focus only the important stuff.
Learn how to build Functional Reactive Applications with Elm, Node.js and Inf...J On The Beach
Developers aim to write responsive, scalable, fault tolerant, reactive applications to can handle the business needs of the modern web applications without hiccups. This talk shows you how to do just that! And to add a twist, we will do it in a (pure) functional style.
Node.js is a very popular framework for developing asynchronous, event-driven, reactive applications. Infinispan, an in-memory distributed data grid designed for fast, scalable, elastic access to large volumes of data, has recently gained compatibility with the Node.js ecosystem enabling reactive applications to use it as persistence layer. When combined with Elm, a functional programming language for declaratively creating reactive web applications, these technologies offer a great platform for working with highly responsive, data-heavy applications seamlessly. In this live-coding talk, we will demonstrate how to use these technologies to build a reactive web application composed of an Elm frontend, a Node.js microservice layer and a scalable, fault tolerant Infinispan data grid for persistence.
Why you should starting programming in Kotlin for Android
Some might think that Kotlin is new.
I will demonstrate Kotlin history, who is behind it, and why is it a must to learn.
With some links and good references
This slides were conducted in GDG 6 October Google i/o event
Some might think that Kotlin is new.
I will demonstrate Kotlin history, who is behind it, and why is it a must to learn.
With some links and good references
This slides were conducted in the 1st kotlin nights event in MENA
Kafka is an open-source distributed commit log addressing low latency, high throughput, scalability, fault-tolerance, and disk-based retention. It can be used to build tracking systems, messaging systems, high performance streaming platforms, real-time analysis, audit log….you name it. In our case, it’s been used to build a scalable event-store and messaging platform that stores billions of messages.
In this talk, we’re taking a closer look at essential Kafka concepts such as partition rebalancing, offset management, replication, producer/broker request fetching, file segments, etc. to understand what makes Kafka so scalable, resilient, performant and fault tolerant. We will also touch upon Kafka transactions to know what they are and how to leverage them. Last but not the least we will highlight some potential pitfalls that one should watch out when going to production with Kafka.
Web components provide a standard way to create reusable custom elements. They allow for encapsulation through features like shadow DOM. Polymer makes it easier to build web components by wrapping the standard API and using lit-html for rendering. LitElement provides a simple base class for building web components with lit-html. While newer, LitElement components are lightweight and have a small, straightforward API. Web components offer benefits like reusability and future compatibility, though polyfills are needed for some browser support currently.
Adding a bit of static type checking to a world of web componentsJordy Moos
Web Components are a set of web platform API that focus on encapsulation and reusability that will soon be supported in all browsers. This means they can be used for free, at the opposite of frameworks like React.
Web Components allow for great modularity, but can actually become very difficult to maintain and extend in large applications.
Could a strongly, statically typed (and pure!) language like Elm solve those issues? This is what we will investigate together...
This document provides an overview of Angular 2.0 and 4.0. It discusses Angular's history from version 1.x to 2 to 4. Major changes include improved performance, modularization, TypeScript support, and a focus on components over controllers and scopes. The Angular CLI is introduced for scaffolding and building Angular applications. Features that set Angular apart from AngularJS like templates, change detection, and routing are covered. The process of migrating from Angular 2 to 4 is outlined. Demos of Angular as a PWA and with Electron are presented.
PHP Conference Japan 2019 Track6-5 Aurimas Niekis - How to Supercharge your PHP Web API
https://phpcon.php.gr.jp/2019/
https://www.youtube.com/watch?v=ZtTvUQCDDTM
Here are the slides for the presentation that Shai Reznik and I gave at Angular Connect 2015. Our presentation is 5-minutes of meaningful content wrapped in another 20 minutes of wackiness that pokes fun at a lot of other memorable keynotes we have seen.
Jean-Roche Maitre and Joris TIrado discuss the basics of coding a Monster app, which will track all new call events happening on a Kazoo Account. The goal is to see the events in our app as we place calls from a softphone!
RubyMotion is a commercial toolchain that allows developers to build iOS, Android, and OS X apps using the Ruby programming language. It compiles Ruby code into native applications that can access platform APIs. This allows developers to write apps once in Ruby and share code across platforms while isolating platform-specific code. RubyMotion apps can be packaged for distribution in app stores. The presentation demonstrated RubyMotion and discussed supported libraries, platforms, IDE integration, and resources for learning more.
The document discusses changes to Android development at Merari since 2014. It summarizes that they have kept daily standup meetings between Tokyo and San Francisco offices. They have also kept one source code base but target two products for the US and JP markets by using flavors. Issues worked on include streamlining the translation process and reducing app size. Current work involves developing an in-house analysis platform and AB testing tool to have more control and insights.
DBI for Parrot and Perl 6 Lightning Talk 2007Tim Bunce
This lightning talk proposes adopting the Java JDBC API specification as a common database driver API for Parrot and open source languages. Currently, database interfaces for most languages are limited, different from each other, and involve duplicative development efforts. A common API based on the mature and well-documented JDBC standard could allow drivers to be shared across languages and improve functionality. The speaker is already working on a Perl module that implements the JDBC API and a Summer of Code project to explore a Perl 6 implementation of the DBI API using this module.
Have you ever wanted to automatically turn on your lights when you get home, or turn them back off when you leave? What about controlling your lights by SMS or IRC? This presentation will teach you how to automate your life with location-based hacks and SMS.
Blazor and Azure Functions - a serverless approachAlex Pshul
Blazor allows us to write code in C# that will run on your browser. No need to panic, this is not Silverlight. :)
The generated WebAssembly can be stored on an Azure Storage, instead of a server which processes requests, which on the one hand can save money and on the other hand, server a large amount of users.
For the backend, to leverage the serverless concept, Azure Functions can provide some easy to write endpoints, which will allow us to have a fully serverless WebApp with a functioning backend.
Crystal is a programming language that aims to provide Ruby-like syntax with C-like performance. It compiles to efficient native code without needing to specify variable or argument types. Crystal installation is simple on Linux, macOS, and Windows. Programs can be run, built, and compiled directly from the command line. While still in pre-alpha, the language is designed and its compiler written in Crystal. Porting Ruby code to Crystal is easy with few needed modifications. Current limitations include a lack of incremental compilation and difficulty implementing a REPL due to Crystal not being dynamically typed.
React Native - Why Designers should use React native. And everyone else too.Val Scholz
This is from my talk "Why Designers should use React Native. And everyone else too" which I prepared for the React Native meet up in Vienna.
The talk gives a brief introduction to React Native and why it's so great for mobile development.
Inspired by the talk of Pieter De Baets
- Ruby and Scala both provide object oriented and functional programming capabilities but Scala aims to have better performance than Ruby while providing less ceremony than Java.
- Both languages have vibrant communities and encourage testing, but Scala emphasizes letting the compiler do more work and provides concurrency features while Ruby emphasizes flexibility, elegance and fun.
- Common tasks like routing, templates, unit tests and specs are similar between Rails and Play frameworks for Ruby and Scala respectively, though Ruby uses more optional conventions while Scala requires more strict conventions.
Integration Patterns for Mission Critical SystemsAngelo Corsaro
This document provides an overview of integration patterns for mission/business critical systems of systems based on Data Distribution Service (DDS). It discusses common integration challenges such as data integration, data policing, impedance/quality of service (QoS) adaptation, and technology integration. It then describes specific integration patterns for data integration, impedance/QoS adaptation, and security. The document concludes by discussing how the OpenSplice Gateway leverages integration frameworks to enable connectivity and integration across DDS and other technologies.
Session presented at the 6th IndicThreads.com Conference on Java held in Pune, India on 2-3 Dec. 2011.
http://Java.IndicThreads.com
---
My talk would describe how to build DSL’s using Scala, what features in Scala help make it a great option for building DSL’s and some examples of DSL’s built in Scala.
http://www.indicthreads.com/9254/using-scala-for-building-dsls/
Why you should starting programming in Kotlin for Android
Some might think that Kotlin is new.
I will demonstrate Kotlin history, who is behind it, and why is it a must to learn.
With some links and good references
This slides were conducted in GDG 6 October Google i/o event
Some might think that Kotlin is new.
I will demonstrate Kotlin history, who is behind it, and why is it a must to learn.
With some links and good references
This slides were conducted in the 1st kotlin nights event in MENA
Kafka is an open-source distributed commit log addressing low latency, high throughput, scalability, fault-tolerance, and disk-based retention. It can be used to build tracking systems, messaging systems, high performance streaming platforms, real-time analysis, audit log….you name it. In our case, it’s been used to build a scalable event-store and messaging platform that stores billions of messages.
In this talk, we’re taking a closer look at essential Kafka concepts such as partition rebalancing, offset management, replication, producer/broker request fetching, file segments, etc. to understand what makes Kafka so scalable, resilient, performant and fault tolerant. We will also touch upon Kafka transactions to know what they are and how to leverage them. Last but not the least we will highlight some potential pitfalls that one should watch out when going to production with Kafka.
Web components provide a standard way to create reusable custom elements. They allow for encapsulation through features like shadow DOM. Polymer makes it easier to build web components by wrapping the standard API and using lit-html for rendering. LitElement provides a simple base class for building web components with lit-html. While newer, LitElement components are lightweight and have a small, straightforward API. Web components offer benefits like reusability and future compatibility, though polyfills are needed for some browser support currently.
Adding a bit of static type checking to a world of web componentsJordy Moos
Web Components are a set of web platform API that focus on encapsulation and reusability that will soon be supported in all browsers. This means they can be used for free, at the opposite of frameworks like React.
Web Components allow for great modularity, but can actually become very difficult to maintain and extend in large applications.
Could a strongly, statically typed (and pure!) language like Elm solve those issues? This is what we will investigate together...
This document provides an overview of Angular 2.0 and 4.0. It discusses Angular's history from version 1.x to 2 to 4. Major changes include improved performance, modularization, TypeScript support, and a focus on components over controllers and scopes. The Angular CLI is introduced for scaffolding and building Angular applications. Features that set Angular apart from AngularJS like templates, change detection, and routing are covered. The process of migrating from Angular 2 to 4 is outlined. Demos of Angular as a PWA and with Electron are presented.
PHP Conference Japan 2019 Track6-5 Aurimas Niekis - How to Supercharge your PHP Web API
https://phpcon.php.gr.jp/2019/
https://www.youtube.com/watch?v=ZtTvUQCDDTM
Here are the slides for the presentation that Shai Reznik and I gave at Angular Connect 2015. Our presentation is 5-minutes of meaningful content wrapped in another 20 minutes of wackiness that pokes fun at a lot of other memorable keynotes we have seen.
Jean-Roche Maitre and Joris TIrado discuss the basics of coding a Monster app, which will track all new call events happening on a Kazoo Account. The goal is to see the events in our app as we place calls from a softphone!
RubyMotion is a commercial toolchain that allows developers to build iOS, Android, and OS X apps using the Ruby programming language. It compiles Ruby code into native applications that can access platform APIs. This allows developers to write apps once in Ruby and share code across platforms while isolating platform-specific code. RubyMotion apps can be packaged for distribution in app stores. The presentation demonstrated RubyMotion and discussed supported libraries, platforms, IDE integration, and resources for learning more.
The document discusses changes to Android development at Merari since 2014. It summarizes that they have kept daily standup meetings between Tokyo and San Francisco offices. They have also kept one source code base but target two products for the US and JP markets by using flavors. Issues worked on include streamlining the translation process and reducing app size. Current work involves developing an in-house analysis platform and AB testing tool to have more control and insights.
DBI for Parrot and Perl 6 Lightning Talk 2007Tim Bunce
This lightning talk proposes adopting the Java JDBC API specification as a common database driver API for Parrot and open source languages. Currently, database interfaces for most languages are limited, different from each other, and involve duplicative development efforts. A common API based on the mature and well-documented JDBC standard could allow drivers to be shared across languages and improve functionality. The speaker is already working on a Perl module that implements the JDBC API and a Summer of Code project to explore a Perl 6 implementation of the DBI API using this module.
Have you ever wanted to automatically turn on your lights when you get home, or turn them back off when you leave? What about controlling your lights by SMS or IRC? This presentation will teach you how to automate your life with location-based hacks and SMS.
Blazor and Azure Functions - a serverless approachAlex Pshul
Blazor allows us to write code in C# that will run on your browser. No need to panic, this is not Silverlight. :)
The generated WebAssembly can be stored on an Azure Storage, instead of a server which processes requests, which on the one hand can save money and on the other hand, server a large amount of users.
For the backend, to leverage the serverless concept, Azure Functions can provide some easy to write endpoints, which will allow us to have a fully serverless WebApp with a functioning backend.
Crystal is a programming language that aims to provide Ruby-like syntax with C-like performance. It compiles to efficient native code without needing to specify variable or argument types. Crystal installation is simple on Linux, macOS, and Windows. Programs can be run, built, and compiled directly from the command line. While still in pre-alpha, the language is designed and its compiler written in Crystal. Porting Ruby code to Crystal is easy with few needed modifications. Current limitations include a lack of incremental compilation and difficulty implementing a REPL due to Crystal not being dynamically typed.
React Native - Why Designers should use React native. And everyone else too.Val Scholz
This is from my talk "Why Designers should use React Native. And everyone else too" which I prepared for the React Native meet up in Vienna.
The talk gives a brief introduction to React Native and why it's so great for mobile development.
Inspired by the talk of Pieter De Baets
- Ruby and Scala both provide object oriented and functional programming capabilities but Scala aims to have better performance than Ruby while providing less ceremony than Java.
- Both languages have vibrant communities and encourage testing, but Scala emphasizes letting the compiler do more work and provides concurrency features while Ruby emphasizes flexibility, elegance and fun.
- Common tasks like routing, templates, unit tests and specs are similar between Rails and Play frameworks for Ruby and Scala respectively, though Ruby uses more optional conventions while Scala requires more strict conventions.
Integration Patterns for Mission Critical SystemsAngelo Corsaro
This document provides an overview of integration patterns for mission/business critical systems of systems based on Data Distribution Service (DDS). It discusses common integration challenges such as data integration, data policing, impedance/quality of service (QoS) adaptation, and technology integration. It then describes specific integration patterns for data integration, impedance/QoS adaptation, and security. The document concludes by discussing how the OpenSplice Gateway leverages integration frameworks to enable connectivity and integration across DDS and other technologies.
Session presented at the 6th IndicThreads.com Conference on Java held in Pune, India on 2-3 Dec. 2011.
http://Java.IndicThreads.com
---
My talk would describe how to build DSL’s using Scala, what features in Scala help make it a great option for building DSL’s and some examples of DSL’s built in Scala.
http://www.indicthreads.com/9254/using-scala-for-building-dsls/
#1 The diversity of terminology shows the large spectrum of shapes DSLs can take.
#2 As syntax and development environment matter, DSLs should allow the user to choose the right shape according to their usage or task.
#3 A metamorphic DSL vision is proposed where DSLs can adapt to the most appropriate shape, including transitioning between shapes based on usage or task.
This document discusses common integration patterns used in architectural designs. It describes five main patterns: migration, broadcast, aggregation, bi-directional synchronization, and correlation. The migration pattern allows moving data from one system to another at a specific time. The broadcast pattern distributes data from one source to multiple destinations to keep data up-to-date across systems. The aggregation pattern collects data from multiple sources and merges it into a single system. The bi-directional synchronization pattern maintains consistent and up-to-date data across multiple interconnected systems. Finally, the correlation pattern links related events or data elements within or across systems.
Java Messaging Service (JMS) is a specification that describes a common way for Java programs to create, send, receive and read distributed enterprise messages using a loosely coupled and asynchronous messaging approach. A JMS provider delivers messages to clients as they arrive without requiring the client to request them. JMS supports point-to-point, publish-subscribe, and request-reply messaging domains. The JMS API defines programming elements like connections, sessions, producers and consumers that Java programs use to participate in messaging.
Spoilt for Choice: How to Choose the Right Enterprise Service Bus (ESB)?Kai Wähner
Data exchanges in and between companies increase a lot. The number of applications which must be integrated increases, too. As solution, an Enterprise Service Bus (ESB) can be used in almost every integration project - no matter which technologies, transport protocols, data formats, or environments such as Java or .NET are used. All integration projects can be realized in a consistent way without redundant boilerplate code. However, an ESB offers many further features, such as business process management (BPM), master data management, business activity monitoring, or big data. Plenty of ESB products are on the market which differ a lot regarding concepts, programming models, tooling, and open source vs. proprietary. Really one is spoilt for choice.
The Enterprise Service Bus is Dead! Long live the Enterprise Service Bus, Rim...confluent
The document discusses how Heroku leveraged Apache Kafka to realize the vision of an enterprise service bus (ESB). It defines what an ESB is according to analysts and vendors. Heroku defined the API as its ESB but faced bottlenecks and reliability issues. It transitioned to using Kafka with a pull-based architecture for independent development, scalability, and avoiding single points of failure. Heroku now uses Kafka for operational data pipelines and metrics aggregation. It provides examples of using Kafka topics and discusses next steps of implementing a schema registry and security.
Integration patterns and practices for cloud and mobile computingSHAKIL AKHTAR
This document discusses integration patterns and practices for cloud and mobile computing. It begins with an introduction to the presenter and an overview of the topics to be covered, including enterprise integration patterns (EIPs), integration best practices for connected systems, patterns for cloud and mobile computing, and use cases. Various integration styles, patterns for cloud-to-cloud and mobile integration are described. The document provides examples of real-time, queue-based and event-based integration approaches for enterprise mobile applications.
This presentation introduces the key concepts at the foundation of DDS, the data distribution service for real-time systems. Wether you are a new to DDS or a relatively experienced user, you'll find this presentation a good source of information.
Microservices - Death of the Enterprise Service Bus (ESB)? (Update 2016)Kai Wähner
Microservices are the next step after SOA: Services implement a limited set of functions. Services are developed, deployed and scaled independently.
Continuous Integration and Continuous Delivery control deployments. This way you get shorter time to results and increased flexibility. Microservices have to be independent regarding build, deployment, data management and business domains. A solid Microservices design requires single responsibility, loose coupling and a decentralized architecture. A Microservice can to be closed or open to partners and public via APIs. This session discusses the requirements, best practices and challenges for creating a good Microservices architecture, and if this spells the end of the Enterprise Service Bus (ESB). A live demo will show how middleware and Microservices complement each other using containers, continuous integration, REST services, and open source frameworks such as Cloud Foundry.
A live demo showed a "Microservices Middleware Architecture" using Cloud Integration (with Cloud Foundry PaaS), Integration and Services (with TIBCO BusinessWorks Container Edition), API Management / Open API (with Mashery) amd Log Management / IT Operations Analytics (ITOA, with Papertrail and LogLogic / Unity).
Overview of JMS messaging API.
JMS (Java Messaging Service) is an API for asynchronous message based communication between Java based applications.
JMS implementations (instances that implement the JMS API) are called JMS providers.
JMS defines two messaging domains. Point-to-point queues are typically used between one or multiple message senders and a single message receiver.
Topics are multi-point queues where messages are distributed to multiple receivers. As such topics resemble a black board.
Like many other message oriented middleware technologies, JMS provides advanced functions like persistent message delivery mode or different message acknowledgment modes.
Additionally, messages can be sent and received in a transacted mode thus ensuring that either all or no messages are sent and received.
JMS integrates into EJB (Enterprise Java Beans) through message driven beans.
Showdown: Integration Framework (Spring Integration, Apache Camel) vs. Enterp...Kai Wähner
I had a talk at Java User Group Frankfurt (JUGF): "Showdown: Integration Framework (Spring Integration, Apache Camel) vs. Enterprise Service Bus (ESB)". The room was fully packed, interest in integration frameworks, ESBs, and corresponding tooling is increasing every year!
Kotlin fait partie de ces "nouveaux" langages de la JVM qui changent la donne. Bien qu'il ait un impact important sur Android, il fait également des merveilles côté serveur. Comme les Domain-Specific Languages (DSL) sont contraints par le langage avec lequel ils sont conçus, Kotlin libère les développeurs des "fluent builders" Java pour proposer quelque chose de mieux.
En utilisant le framework web Vaadin comme exemple, je ferais une démo de comment l'on peut concevoir son propre DSL avec Kotlin.
Stencil the time for vanilla web components has arrivedGil Fink
This document discusses how Stencil can help solve problems with creating custom web components. Stencil is a compiler that generates standard-compliant web components from components written with features like JSX and TypeScript. It addresses issues like verbose syntax and lack of framework features by generating code that includes capabilities like virtual DOM and reactivity. Stencil works at build time so generated components can be used by any framework and are suitable for building reusable infrastructure components.
React, Angular, TypeScript… Over the past few years, all these names took part in a fashionable phenomenon, pushed by the big names of the web industry. But what if a parallel world exists beyond this marketed mirror? A better world where you can easily build flexible applications with reusable components. Bourre will explain the right philosophy for building flexible applications with reusable components. As well, he will showcase the few tools to better achieve these goals, pushing forward the limits of the JS eco-system.
The document discusses internal domain-specific languages (DSLs). It begins by explaining how fluent interfaces originated and their benefits. It then discusses how fluent interfaces relate to the builder pattern and how they can be used to create internal DSLs. The document provides examples of internal DSL implementations in different programming languages and outlines design guidelines and patterns for creating internal DSLs, such as using context, pure, and glue primitives. It also discusses how to implement entry and exit points and rules for contextual transitions within an internal DSL.
The document discusses how web components using HTML templates, shadow DOM, custom elements, and HTML imports can help build encapsulated, reusable, and extensible UI components. It provides examples of how these technologies allow defining components with private styles and markup, standard component lifecycles, and declarative composition through templates and content projection. Overall, the document argues these techniques help address issues like style encapsulation, maintainability, and scalability when building applications with web technologies.
Sprache als Werkzeug: DSLs mit Kotlin (JAX 2020)Frank Scheffler
Domänenspezifische Sprachen (engl. DSLs) sind seit jeher dazu geeignet, komplexe Ausdrücke kompakter und besser lesbar auszudrücken. Dabei befreien sie den Benutzer von der Notwendigkeit, wiederkehrende Programmfragmente zu pflegen. Sie reduzieren den Blick auf den wesentlichen Inhalt der zugrunde liegenden Domäne. Während es an sinnvollen Anwendungsgebieten von DSLs nicht mangelt, sind deren Funktionsweise und Erstellung oftmals zu Unrecht als Mysterium verschrieen. Domänenspezifische Sprachen unterteilen sich grundsätzlich in externe und interne DSLs. Externe DSLs definieren eine unabhängige eigene Sprache, z. B. Xtend oder SQL. Daher bedarf es zu deren Ausführung einer eigenständigen Syntaxanalyse, -validierung und eines Compilers oder Interpreters. Interne DSLs basieren auf Host-Programmiersprachen. Daher ist ihr Sprachumfang nicht abgeschlossen, sondern lässt sich durch deren Sprachelemente erweitern. Kotlin bietet mit Extension Functions und Lambdas with Receivers ideale Voraussetzungen für die Erstellung interner DSLs. Dies zeigt auch ein Blick auf die ständig wachsende Zahl von Kotlin-basierten DSLs, wie z. B. der Kotlin Gradle DSL oder der Spring Beans DSL. In diesem Vortrag sollen die Grundlagen zur Erstellung eigener DSLs mit Kotlin vermittelt werden. Anhand eines praxisorientierten Beispiels wird schrittweise eine DSL während des Vortrags erstellt.
Anko - The Ultimate Ninja of Kotlin Libraries?Kai Koenig
Kotlin is a new language for the JVM that aims to be a ””better Java”“. Made in-house by Jetbrains, the company behind IntelliJ IDEA and also Android Studio, it’s been in development for more than 5 years. Just a few weeks ago the final version of Kotlin 1.0 saw the light of day.
The language itself gives one so much niceness and syntactic sugar that you’d probably never want to go back to coding in Java again. Things get even better with Anko. Anko is pretty much the ultimate Ninja of Kotlin libraries. The feature it’s best know for is its Layout DSL that allows one to programatically write UI code in Kotlin. No more XML layout and no awkward piecing together of your UI through clunky Java APIs. We will look at how to use and how to extend the Layout DSL for your own requirements and then move on to Anko’s advanced, non-layout-related features:
- Intent wrappers
- Shortcuts to system services
- Asynchronous task management
- Anko SQLite and more
Lieven DOCLO gave a presentation on implementing Clean Architecture. Clean Architecture advocates separating domains, applications, and interfaces into separate layers. This allows the inner layers to be independent of the outer layers and frameworks. The presentation demonstrated creating building-related use cases and domain models, implementing repositories, and exposing use cases through REST endpoints. It discussed issues like decoupling tradeoffs, pragmatic compromises, and applying Clean Architecture to legacy projects.
Building Websites of the Future With Drupal 7Jay Epstein
- Drupal is an open-source content management system (CMS) that can be used to create websites and applications. It was originally created in 2001 by Dries Buytaert as a college project.
- Drupal has grown significantly since then and is now used by over 2% of the top million websites worldwide. Major sites like the White House, PopSci, and The Economist use Drupal.
- Drupal provides tools and modules for building websites, including content types, themes, blocks, views, taxonomy, and user roles and permissions. It is highly customizable and can scale from basic personal sites to large complex sites.
Building Websites of the Future With Drupal 7Jay Epstein
- Drupal is an open-source content management system (CMS) that can be used to create websites and applications. It was originally created in 2001 by Dries Buytaert as a message board for a student project.
- Drupal has grown significantly since then and is now used by over 2% of the top million websites worldwide. Major sites like the White House, Economist, and Warner Bros use Drupal.
- Drupal provides tools and modules for building websites, including content types, themes, blocks, views, taxonomy, and user roles/permissions to control site access and functionality. It is highly customizable and can scale from basic personal sites to large complex sites.
"Xapi-lang For declarative code generation" By James NelsonGWTcon
Xapi-lang is a Java parser enhanced with an XML-like syntax that can be used for code generation, templating, and creating domain-specific languages. It works by parsing code into an abstract syntax tree and then applying visitors to analyze and transform the AST to produce output. Examples shown include class templating, API generation from templates, and UI component generation. The document also discusses best practices for code generation and outlines plans for rebuilding the GWT toolchain to support GWT 3 and J2CL. It promotes a new company, Vertispan, for GWT support and consulting and introduces another project called We The Internet for building tools to improve political systems using distributed democracy.
This document discusses strategies for moving applications to the cloud, including "lift and shift" and full rewrites. It advocates for a middle path of reusing existing code but changing how frameworks are used. Specific frameworks and technologies mentioned include Quarkus, Kotlin, Hazelcast, and GraalVM. The document also provides an example application of a URL shortener and how it could be implemented using these strategies and technologies.
The document provides an introduction to developing complex front-end applications using HTML and JavaScript. It discusses how JavaScript modules can be organized in a way that is similar to frameworks like WPF and Silverlight using simple constructs like the module pattern. It also covers asynchronous module definition (AMD) and how modules can be loaded and dependencies managed using RequireJS. The document demonstrates unit testing jQuery code and using pubsub for loose coupling between modules. Finally, it discusses how CSS compilers like SASS can make CSS authoring more productive by allowing variables, nesting and mixins.
Not Just a Pretty Face: How to design and build a cross-CMS CSS frameworkcrystalenka
A presentation from J and Beyond 2018 in Cologne, Germany. In this session, Crystal of Lucid Fox will walk you through the steps she took to build Akeeba FEF, a CSS framework that Akeeba now uses to ensure their extensions are consistent with their brand across Joomla, WordPress, and standalone PHP software. You’ll learn about creating a design system, writing CSS in a way that’s easily maintained and upgraded, and tips on implementing this system across multiple platforms.
Kotlin is a programming language that runs on the Java Virtual Machine and JavaScript. It was created by JetBrains as an alternative to Java that allows code to be written in fewer lines using less verbose syntax. Kotlin is fully interoperable with Java code and is becoming a preferred language for Android development due to its support by Android Studio. The document discusses Kotlin's history, capabilities, and provides examples of how code can be written more concisely in Kotlin compared to Java. It recommends resources for learning Kotlin and says that while there is a learning curve, it may be beneficial for new projects, especially Android development.
Everything-as-code – Polyglotte Entwicklung in der PraxisQAware GmbH
IT-Tage 2017, Frankfurt am Main: Vortrag von Mario-Leander Reimer (@LeanderReimer, Cheftechnologe bei QAware)
Abstract:
Als zeitgemäßer Entwickler muss man eine Vielzahl an Sprachen sicher beherrschen. Wir definieren unsere Entwicklungsumgebung mit Gradle, wir bauen unsere Software in Java, Kotlin und JavaScript. Wir verwenden Groovy und Scala um unsere Software zu testen. Die Build-Pipeline wird per DSL und JSON definiert. Mit YAML und Python beschreiben wir die Infrastruktur und das Deployment unserer Anwendungen. Die Dokumentation unserer Architekturen erledigen wir mit AsciiDoc und JRuby.
Use the right tool for the job! Das ist das Motto dieser Session. Jede Sprache hat Stärken in einer bestimmten Domäne. Diese Stärken gilt es zu nutzen. Aber einfach blind jede gerade angesagte Sprache oder Technologie einzusetzen, ist sicher nicht die Lösung. Dieser Vortrag führt durch die einzelnen Entwicklungs-Phasen eines Microservice und zeigt dabei einen in der Praxis erprobten, stabilen und gut integrierten polyglotten Technologie-Stack um moderne Enterprise-Applikationen schnell und einfach zu entwickeln.
What is DocuOps. How does Asciidoctor contribute? How to add it to your Maven & Gradle build. Tying all of the tech documentation together in a single project from commit to publish.
Similar to Java One - Designing a DSL in Kotlin (20)
SnowCamp - Adding search to a legacy applicationNicolas Fränkel
Most applications evolve to a point where they need to provide search capabilities. But updating an application is always a risk. Plus, sometimes, you don’t have access to the source code. The easiest way to access the data is by getting them directly from the database.
The initial load is the easiest step. However, how do you keep the search index in sync with the database? How do you keep the latency between the search store and the source of truth, so your users don’t have to wait for the next run of the batch to access the newest changes?
In this live coding session, we will show you how you can solve this issue by connecting Elasticsearch to the database with a touch of Hazelcast.
On dit que GitHub est le CV d'un développeur. Un rapide coup d'œil à votre historique de commit et les recruteurs savent tout de vous. Cette approche comporte quelques problèmes. La plupart des entreprises ne publient même pas leur code sous une licence Open Source. Si vous travaillez pour l'une d'entre elles, et si vous n'êtes pas un développeur Open Source les soirs et les week-ends, alors vous n'avez aucune chance.
Récemment, GitHub a permis un certain degré de personnalisation de son profil. Ainsi, même si votre historique de commit a plus de blanc que de vert, vous pouvez fournir un bon point d'entrée pour les employeurs potentiels. Mais ça ne vaut que l'effort que vous y mettez et les données perdent leur valeur rapidement. Pourtant, avec un peu de travail et l'aide d'outils d'automatisation (tels que GitHub Actions), vous pouvez présenter un profil toujours à jour.
Zero-downtime deployment on Kubernetes with HazelcastNicolas Fränkel
Kubernetes allows a lot. After discovering its features, it’s easy to think it can magically transform your application deployment process into a painless no-event. For Hello World applications, that is the case. Unfortunately, not many of us do deploy such applications day-to-day because we need to handle state. Though it would be much easier to have stateless apps, and despite our best efforts in this direction, state is found in (at least) two places: sessions and databases.
You need to think keeping the state while stopping and starting application nodes. In this talk, I’ll demo how to update a Spring Boot app deployed on a Kubernetes cluster with a non-trivial database schema change with the help of Hazelcast, while keeping the service up during the entire update process.
jLove - A Change-Data-Capture use-case: designing an evergreen cacheNicolas Fränkel
When one’s app is challenged with poor performances, it’s easy to set up a cache in front of one’s SQL database. It doesn’t fix the root cause (e.g. bad schema design, bad SQL query, etc.) but it gets the job done. If the app is the only component that writes to the underlying database, it’s a no-brainer to update the cache accordingly, so the cache is always up-to-date with the data in the database.
Things start to go sour when the app is not the only component writing to the DB. Among other sources of writes, there are batches, other apps (shared databases exist unfortunately), etc. One might think about a couple of ways to keep data in sync i.e. polling the DB every now and then, DB triggers, etc. Unfortunately, they all have issues that make them unreliable and/or fragile.
You might have read about Change-Data-Capture before. It’s been described by Martin Kleppmann as turning the database inside out: it means the DB can send change events (SELECT, DELETE and UPDATE) that one can register to. Just opposite to Event Sourcing that aggregates events to produce state, CDC is about getting events out of states. Once CDC is implemented, one can subscribe to its events and update the cache accordingly. However, CDC is quite in its early stage, and implementations are quite specific.
In this talk, I’ll describe an easy-to-setup architecture that leverages CDC to have an evergreen cache.
BigData conference - Introduction to stream processingNicolas Fränkel
This document discusses stream processing and summarizes a presentation about the topic. It introduces Hazelcast Jet as a stream processing engine and covers open data standards like GTFS. It also describes a demo that uses GTFS data to enrich public transit vehicle position updates in real-time using Hazelcast Jet. The presentation discusses streaming approaches, benefits over batch processing, and provides an overview of stream processing concepts.
ADDO - Your own Kubernetes controller, not only in GoNicolas Fränkel
In Kubernetes, operators allow the API to be extended to your heart content. If one task requires too much YAML, it’s easy to create an operator to take care of the repetitive cruft, and only require a minimum amount of YAML.
On the other hand, since its beginnings, the Go language has been advertised as closer to the hardware, and is now ubiquitous in low-level programming. Kubernetes has been rewritten from Java to Go, and its whole ecosystem revolves around Go. For that reason, It’s only natural that Kubernetes provides a Go-based framework to create your own operator. While it makes sense, it requires organizations willing to go down this road to have Go developers, and/or train their teams in Go. While perfectly acceptable, this is not the only option. In fact, since Kubernetes is based on REST, why settle for Go and not use your own favorite language?
In this talk, I’ll describe what is an operator, how they work, how to design one, and finally demo a Java-based operator that is as good as a Go one.
TestCon Europe - Mutation Testing to the Rescue of Your TestsNicolas Fränkel
Unit testing ensures your production code is relevant. But what does ensure your testing code is relevant? Come discover mutation testing and make sure your never forget another assert again.
In the realm of testing, the code coverage metrics is the most often talked about. However, it doesn’t mean that the test has been useful or even that an assert has been coded. Mutation testing is a strategy to make sure that the test code is relevant.
In this talk, Nicolas will explain how Code Coverage is computed and what its inherent flaw is. Afterwards, he will describe how Mutation Testing work and how it helps pointing out code that is tested but leave out corner cases. He will also demo PIT, a Java production-grade framework that enables Mutation Testing.
OSCONF Jaipur - A Hitchhiker's Tour to Containerizing a Java applicationNicolas Fränkel
As “the Cloud” becomes more and more widespread, now is a good time to assess how you can containerize your Java application. I assume you’re able to write a a Dockerfile around the generated JAR. However, each time the application’s code will change, the whole image will need to be rebuilt. If you’re deploying to a local Kubernetes cluster environment, this increases that much the length of the feedback loop.
In this demo-based talk, I’ll present different ways to get your Java app in a container: Dockerfile, Jib, and Cloud Native Buildpacks. We will also have a look at what kind of Docker image they generate, how they layer the images, whether those images are compatible with skaffold, etc.
GeekcampSG 2020 - A Change-Data-Capture use-case: designing an evergreen cacheNicolas Fränkel
CDC is a brand new approach that "turns the database inside out": it allows to get events out of the database state. This can be leveraged to get a cache that is never stale.
JavaDay Istanbul - 3 improvements in your microservices architectureNicolas Fränkel
While a microservices architecture is more scalable than a monolith, it has a direct hit on performance.
To cope with that, one performance improvement is to set up a cache. It can be configured for database access, for REST calls or just to store session state across a cluster of server nodes. In this demo-based talk, I’ll show how Hazelcast In-Memory Data Grid can help you in each one of those areas and how to configure it. Hint: it’s much easier than one would expect.
At a point in the past, it was forecast that Java would die, but the JVM platform would be its legacy. And in fact, for a long time, the JVM has been tremendously successful. Wikipedia itself lists a bunch of languages that run on it, some of them close to Java e.g. Kotlin, some of them very remote e.g. Clojure.
But nowadays, the Cloud is becoming ubiquitous. Containerization is the way to go to alleviate some of the vendor lock-in issues. Kubernetes is a de facto platform. If a container needs to be killed for whatever reason (resource consumption, unhealthy, etc.), a new one needs to replace it as fast as possible. In that context, the JVM seems to be a dead-end: its startup time is huge in comparison to a native process. Likewise, it consumes a lot of memory that just increase the monthly bill.
What does that mean for us developers? Has all the time spent in learning the JVM ecosystem been invested with no hope of return over investment? Shall we need to invest even more time in new languages, frameworks, libraries, etc.? That is one possibility for sure. But we can also leverage our existing knowledge, and embrace the Cloud and containers ways with the help of some tools.
In this talk, I’ll create a simple URL shortener with a “standard” stack: Kotlin, JAX-RS and Hazelcast. Then, with the help of Quarkus and GraalVM, I’ll turn this application into a native executable with all Cloud/Container related work has been moved to the build process.
Devclub.lv - Introduction to stream processingNicolas Fränkel
While “software is eating the world”, those who are able to best manage the huge mass of data will emerge out on the top.
The batch processing model has been faithfully serving us for decades. However, it might have reached the end of its usefulness for all but some very specific use-cases. As the pace of businesses increases, most of the time, decision-makers prefer slightly wrong data sooner, than 100% accurate data later. Stream processing – or data streaming – exactly matches this usage: instead of managing the entire bulk of data, manage pieces of them as soon as they become available.
OSCONF Koshi - Zero downtime deployment with Kubernetes, Flyway and Spring BootNicolas Fränkel
Kubernetes allows a lot. After discovering its features, it’s easy to think it can magically transform your application deployment process into a painless no-event. For Hello World applications, that is the case. Unfortunately, not many of us do deploy such applications day-to-day. You need to think about application backward compatibility, possible rollback, database schema migration, etc. I believe the later is one of the biggest pain point. In this talk, I’ll demo how to update a Spring Boot app deployed on a Kubernetes cluster with a non-trivial database schema migration with the help of Flyway, while keeping the service up during the entire update process.
JOnConf - A CDC use-case: designing an Evergreen CacheNicolas Fränkel
This document discusses using change data capture (CDC) and Hazelcast Jet to build an evergreen cache that remains in sync with a database. It covers alternatives to cache invalidation like polling and triggers, introduces CDC and the Debezium implementation, and proposes a Jet job that watches database change events, analyzes them, and updates the cache accordingly to solve the cache freshness problem.
London In-Memory Computing Meetup - A Change-Data-Capture use-case: designing...Nicolas Fränkel
When one’s app is challenged with poor performances, it’s easy to set up a cache in front of one’s SQL database. It doesn’t fix the root cause (e.g. bad schema design, bad SQL query, etc.) but it gets the job done. If the app is the only component that writes to the underlying database, it’s a no-brainer to update the cache accordingly, so the cache is always up-to-date with the data in the database.
Things start to go sour when the app is not the only component writing to the DB. Among other sources of writes, there are batches, other apps (shared databases exist, unfortunately), etc. One might think about a couple of ways to keep data in sync i.e. polling the DB every now and then, DB triggers, etc. Unfortunately, they all have issues that make them unreliable and/or fragile.
In this talk, I will describe an easy-to-setup architecture that leverages CDC to have an evergreen cache.
This talk will be about the reasons behind the new stream processing model, how it compare to the old batch model, what are their pros and cons, and a list of existing technologies implementing stream processing with their most prominent characteristics. It will contain details of one possible use-case of data streaming that is not possible with batches: display in (near) real-time all trains in Switzerland and their position on a map, beginning with an overview of all the requirements and the design. Finally, using an OpenData endpoint and the Hazelcast platform,showing a working demo implementation of it.
Java.IL - Your own Kubernetes controller, not only in Go!Nicolas Fränkel
In Kubernetes, operators allow the API to be extended to your heart content. If one task requires too much YAML, it’s easy to create an operator to take care of the repetitive cruft, and only require a minimum amount of YAML.
On the other hand, since its beginnings, the Go language has been advertised as closer to the hardware, and is now ubiquitous in low-level programming. Kubernetes has been rewritten from Java to Go, and its whole ecosystem revolves around Go. For that reason, It’s only natural that Kubernetes provides a Go-based framework to create your own operator. While it makes sense, it requires organizations willing to go down this road to have Go developers, and/or train their teams in Go. While perfectly acceptable, this is not the only option. In fact, since Kubernetes is based on REST, why settle for Go and not use your own favorite language?
In this talk, I’ll describe what is an operator, how they work, how to design one, and finally demo a Java-based operator that is as good as a Go one.
The document discusses stream processing and provides an overview of Hazelcast Jet. It begins with explaining why streaming is useful and describes different streaming approaches like event-driven programming. It then provides details on Hazelcast Jet, including its concepts of pipelines and jobs. The document also discusses open data standards like GTFS and demonstrates a sample streaming pipeline that enriches public transportation data from open APIs.
London Java Community - An Experiment in Continuous Deployment of JVM applica...Nicolas Fränkel
A couple of years ago, continuous integration in the JVM ecosystem meant Jenkins. Since that time, a lot of other tools have been made available. But new tools don’t mean new features, just new ways. Besides that, what about continuous deployment? There’s no tool that allows deploying new versions of a JVM-based application without downtime. The only way to achieve zero downtime is to have multiple nodes deployed on a platform, and let that platform achieve that e.g. Kubernetes.
And yet, achieving true continuous deployment of bytecode on one single JVM instance is possible if one changes one’s way of looking at things. What if the compilation could be seen as changes? What if those changes could be stored in a data store, and a listener on this data store could stream those changes to the running production JVM via the Attach API?
In this talk, we'll demo exactly that using Hazelcast and Hazelcast Jet - but it’s possible to re-use the principles that will be shown using other streaming technologies.
OSCONF - Your own Kubernetes controller: not only in GoNicolas Fränkel
This document discusses creating Kubernetes operators and controllers using different programming languages besides Go. It suggests that a Java-based controller is possible using the GraalVM, which allows creating native executables from Java bytecode. Key points covered include what controllers and operators are, that no specific technology stack is required, and that the JVM could be a good option for controller development with GraalVM's support for polyglot programming and creating native applications.
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.
UI5con 2024 - Bring Your Own Design SystemPeter Muessig
How do you combine the OpenUI5/SAPUI5 programming model with a design system that makes its controls available as Web Components? Since OpenUI5/SAPUI5 1.120, the framework supports the integration of any Web Components. This makes it possible, for example, to natively embed own Web Components of your design system which are created with Stencil. The integration embeds the Web Components in a way that they can be used naturally in XMLViews, like with standard UI5 controls, and can be bound with data binding. Learn how you can also make use of the Web Components base class in OpenUI5/SAPUI5 to also integrate your Web Components and get inspired by the solution to generate a custom UI5 library providing the Web Components control wrappers for the native ones.
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
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/
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
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.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
Top 9 Trends in Cybersecurity for 2024.pptxdevvsandy
Security and risk management (SRM) leaders face disruptions on technological, organizational, and human fronts. Preparation and pragmatic execution are key for dealing with these disruptions and providing the right cybersecurity program.
2. ME, MYSELF AND I
2
By day
• Consultant
By night
• Developer
• Blogger
• Book author
• Teacher/trainer
@nicolas_frankel #kotlin #dsl #kaadin
3. HYBRIS, AN SAP COMPANY
3
@nicolas_frankel #kotlin #dsl #kaadin
4. A DSL?
4
“A Domain-Specific Language is
a computer language specialized to a
particular application domain. This is in
contrast to a General-Purpose
Language, which is broadly applicable
across domains.”
-- Wikipedia
@nicolas_frankel #kotlin #dsl #kaadin
15. WHY NOT GROOVY?
email {
from 'dsl-guru@mycompany.com’
to 'john.doe@waitaminute.com’
subject 'The pope has resigned!’
body {
p 'Really, the pope has resigned!’
}
}
15
@nicolas_frankel #kotlin #dsl #kaadin
16. WHY NOT SCALA?
object SquareRoot extends Baysick {
def main(args:Array[String]) = {
10 PRINT "Enter a number"
20 INPUT 'n
30 PRINT "Square root of " % "'n is " % SQRT('n)
40 END RUN
}
}
16
@nicolas_frankel #kotlin #dsl #kaadin