JavaScript used to be confined to the browser. But these days, it becoming increasingly popular in server-side applications in the form of NodeJS. NodeJS provides event-driven, non-blocking I/O model that supposedly makes it easy to build scalable network application. In this talk you will learn about the consequences of combining the event-driven programming model with a prototype-based, weakly typed, dynamic language. We will share our perspective as a server-side Java developer who wasn’t entirely happy about JavaScript in the browser, let alone on the server. You will learn how to use NodeJS effectively in modern, polyglot applications.
NodeJS: the good parts? A skeptic’s view (jmaghreb, jmaghreb2013)Chris Richardson
JavaScript used to be confined to the browser. But these days, it becoming increasingly popular in server-side applications in the form of NodeJS. NodeJS provides event-driven, non-blocking I/O model that supposedly makes it easy to build scalable network application. In this talk you will learn about the consequences of combining the event-driven programming model with a prototype-based, weakly typed, dynamic language. We will share our perspective as a server-side Java developer who wasn’t entirely happy about JavaScript in the browser, let alone on the server. You will learn how to use NodeJS effectively in modern, polyglot applications.
Futures and Rx Observables: powerful abstractions for consuming web services ...Chris Richardson
A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone.
In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available on the JVM. You will learn how to access web services using reactive observables (RxJava), which are asynchronous data streams. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.
Consuming web services asynchronously with Futures and Rx Observables (svcc, ...Chris Richardson
A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone. In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.
Asynchronous I/O in NodeJS - new standard or challenges?Dinh Pham
The document discusses asynchronous I/O in Node.js and compares processing models using processes, threads, and events. It explains how Node.js uses an event-driven and asynchronous model with callbacks to handle non-blocking I/O. It also discusses challenges with callbacks and introduces flow control libraries that can help address issues with readability and debugging of asynchronous code.
Alberto Maria Angelo Paro - Isomorphic programming in Scala and WebDevelopmen...Codemotion
Scala is the only language that can be used to produce code that can be "trans/compiled" for the JVM, in Javascript and in native binary. This allows to write libraries that are usable in JVM and JS using the power of functional programming (i.e. cats, scalaz), generic programming (i.e. shapeless) and macro/scalameta available in Scala. In this talk, we will see how to write a Scala application backend and a SPA (scala.js/scala-js-react) that share the same code as a business logic, datamodels and transparent API call (JVM/JS) in Scala (via autowire/akka-http/circe).
These are the slides to a talk I gave at Pittsburgh techFest 2012. The topic was an overview of the Node.js framework, and how you can use it to build amazing things.
* See more of my work at http://www.codehenge.net
Dan Persa, Maximilian Fellner - The recipe for scalable frontends - Codemotio...Codemotion
The future of e-commerce requires personalized content for each individual customer. With over 20 million active users, Zalando is facing the challenge of making its frontends more scalable in order to achieve this goal. We brought a solution from the backend to the frontend: microservices. In addition to creating Project Mosaic (https://www.mosaic9.org)—our solution for modular frontends—and using a toolbox of modern web technologies like React and Webpack, we built an architecture that can scale to virtually any size and even support targets other than the browser.
Cracking JWT tokens: a tale of magic, Node.JS and parallel computingLuciano Mammino
Learn how you can use some JavaScript/Node.js black magic to crack JWT tokens and impersonate other users or escalate privileges. Just add a pinch of ZeroMQ, a dose of parallel computing, a 4 leaf clover, mix everything applying some brute force and you'll get a powerful JWT cracking potion!
NodeJS: the good parts? A skeptic’s view (jmaghreb, jmaghreb2013)Chris Richardson
JavaScript used to be confined to the browser. But these days, it becoming increasingly popular in server-side applications in the form of NodeJS. NodeJS provides event-driven, non-blocking I/O model that supposedly makes it easy to build scalable network application. In this talk you will learn about the consequences of combining the event-driven programming model with a prototype-based, weakly typed, dynamic language. We will share our perspective as a server-side Java developer who wasn’t entirely happy about JavaScript in the browser, let alone on the server. You will learn how to use NodeJS effectively in modern, polyglot applications.
Futures and Rx Observables: powerful abstractions for consuming web services ...Chris Richardson
A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone.
In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available on the JVM. You will learn how to access web services using reactive observables (RxJava), which are asynchronous data streams. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.
Consuming web services asynchronously with Futures and Rx Observables (svcc, ...Chris Richardson
A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone. In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.
Asynchronous I/O in NodeJS - new standard or challenges?Dinh Pham
The document discusses asynchronous I/O in Node.js and compares processing models using processes, threads, and events. It explains how Node.js uses an event-driven and asynchronous model with callbacks to handle non-blocking I/O. It also discusses challenges with callbacks and introduces flow control libraries that can help address issues with readability and debugging of asynchronous code.
Alberto Maria Angelo Paro - Isomorphic programming in Scala and WebDevelopmen...Codemotion
Scala is the only language that can be used to produce code that can be "trans/compiled" for the JVM, in Javascript and in native binary. This allows to write libraries that are usable in JVM and JS using the power of functional programming (i.e. cats, scalaz), generic programming (i.e. shapeless) and macro/scalameta available in Scala. In this talk, we will see how to write a Scala application backend and a SPA (scala.js/scala-js-react) that share the same code as a business logic, datamodels and transparent API call (JVM/JS) in Scala (via autowire/akka-http/circe).
These are the slides to a talk I gave at Pittsburgh techFest 2012. The topic was an overview of the Node.js framework, and how you can use it to build amazing things.
* See more of my work at http://www.codehenge.net
Dan Persa, Maximilian Fellner - The recipe for scalable frontends - Codemotio...Codemotion
The future of e-commerce requires personalized content for each individual customer. With over 20 million active users, Zalando is facing the challenge of making its frontends more scalable in order to achieve this goal. We brought a solution from the backend to the frontend: microservices. In addition to creating Project Mosaic (https://www.mosaic9.org)—our solution for modular frontends—and using a toolbox of modern web technologies like React and Webpack, we built an architecture that can scale to virtually any size and even support targets other than the browser.
Cracking JWT tokens: a tale of magic, Node.JS and parallel computingLuciano Mammino
Learn how you can use some JavaScript/Node.js black magic to crack JWT tokens and impersonate other users or escalate privileges. Just add a pinch of ZeroMQ, a dose of parallel computing, a 4 leaf clover, mix everything applying some brute force and you'll get a powerful JWT cracking potion!
Nobody likes to wait for web pages to load in the browser. The longer it takes, the more dissatisfied the users become. Slow web pages lead to a higher bounce rate and the loss of customers. To solve this kind of problems can be very hard sometimes. Before you even start to optimise your page, you have to understand the workflows a browser performs in order to display a page on the screen. In this talk you will get some insights in the critical rendering path and the javascript engine of your browser that help you to find performance problems and solve them. I will show you also some tools and best practices that make your life easier when it comes to performance.
This document discusses microservices using Node.js and JavaScript. It covers building an HTTP microservice with Express including routing, structure, database integration, logging and testing. It also discusses building command-based microservices with Seneca including patterns, plugins, and queueing. Finally, it discusses containerization with Docker, API gateways, testing, process management with PM2, and some considerations around when microservices may not be the best solution.
Decompose That WAR! Architecting for Adaptability, Scalability, and Deployabi...Chris Richardson
It’s no longer acceptable to develop large, monolithic, single-language, single-framework Web applications. In this session, you will learn how to use the scale cube to decompose your monolithic Web application into a set of narrowly focused, independently deployable services. The presentation discusses how a modular architecture makes it easy to adopt newer and better languages and technologies. You will learn about the various communication mechanisms—synchronous and asynchronous—that these services can use.
The document discusses JavaScript internals such as scope, closures, prototypes and classes. It explains how scope works in JavaScript and how closures allow functions to access outer scope even when executed outside of it. It also compares prototypical inheritance to classical inheritance in JavaScript and how ES2015 classes provide syntactic sugar for prototypical inheritance with the ability to reference super classes.
This document provides an overview of the MEAN stack and its components. It discusses Node.js and its asynchronous and non-blocking architecture. It introduces MongoDB for data storage. It also covers Express, a web application framework for Node.js, and Angular 2, a front-end framework. Code examples and demos are provided for Node.js, Express, MongoDB integration, and building an Angular 2 application. The document is intended to educate developers on the MEAN stack technologies.
The modern web is feature-rich and fast, and Dart gives you a familiar and productive toolchain to scale up your code and apps. Come learn what's new with the Dart project, and how you can use the class-based language, rich built-in libraries, productive editor, package manager, and more. You want more? How about Web Components and a Future-based DOM! You'll see lots of demos, with special attention to the Dart-to-JavaScript compiler.
Web pages can get very complex and slow. In this talk, I share how we solve some of these problems at LinkedIn by leveraging composition and streaming in the Play Framework. This was my keynote for Ping Conference 2014 ( http://www.ping-conf.com/ ): the video is on ustream ( http://www.ustream.tv/recorded/42801129 ) and the sample code is on github ( https://github.com/brikis98/ping-play ).
If you have ever wanted to code an application with Angular this is your chance. Join us for a fun filled day of learning Angular in this hands-on workshop. You will go from 0 to 60 with your Angular knowledge and be able to create our own Angular applications by the end of this workshop. We will start with a new project and continue to build up the project until we have a full application at the end.
This document contains the slides from a talk given by Konrad Malawski on the "Tao/Zen of Programming" using Akka. Some of the key points discussed include:
- Actors are meant to work together and each actor should focus on a single responsibility. Having only one actor limits its capabilities.
- Actors should be structured in a hierarchy with parent-child relationships to allow for supervision. Actors should also be named meaningfully based on their purpose.
- Blocking operations can starve other actors by monopolizing shared resources. Blocking code needs to be isolated on dedicated dispatchers.
- Messages should be processed asynchronously using for/flatMap instead of awaiting futures to avoid blocking
Lucio Grenzi - Building serverless applications on the Apache OpenWhisk platf...Codemotion
Apache OpenWhisk provides a powerful and flexible environment for deploying cloud-native applications driven by data, message, and API call events. We will show how and why we integrated Apache OpenWhisk and GitHub to make deployment as easy and transparent as `git push`. We will also discuss the benefit of using an open source cloud platform and explain how serverless allows developers to focus on writing value-adding code.
Ruby is designed to make programmers happy by providing simplicity, openness, and an object-oriented yet dynamic programming experience. It aims to focus on humans rather than machines. Ruby promotes productivity through conventions that speed development and testing. Programmers enjoy coding in Ruby due to its immediate feedback and morale boost. Ruby has broad utility across web, text, and GUI applications and is platform agnostic, running on most operating systems.
Node.js is a lightweight but yet capable platform for creating powerful web applications. The core of Node.js is kept small and restricted to a limited functionality that is extended by a vast ecosystem. With the right combination of packages you are able to build full-featured web applications. There is nearly no limit in features starting with simple problems such as authentication or logging over web interfaces with REST or GraphQL to a whole application based on a microservices architecture. In this talk I will introduce you to some commonly used packages and show you how to use them by example.
React Native allows developers to build native mobile apps using JavaScript and React. While it provides benefits like using React for both web and mobile, allowing for code reuse, there are also challenges to using it in production. It is easy for web developers to use initially but documentation is poor and updates can cause breaking changes. Performance has not been an issue yet but native apps are generally faster. While the community is active, third party packages can introduce bugs and the build can sometimes break, especially on Android. Overall, React Native can be used for production apps if challenges around updates and crashes are addressed.
Matteo Manchi - React Native for multi-platform mobile applications - Codemot...Codemotion
Since its 2013 release, React has brought a new way to design UI components in the world wide web. The same fundamentals have been taken to another important environment in our contemporary world: the mobile applications. We'll see the philosophy behind React Native - learn once, write anywhere - and how this new framework helps developers to build native apps using React.
Distributed Consensus A.K.A. "What do we eat for lunch?"Konrad Malawski
Distributed Consensus is everywhere! Even if not obvious at first, most apps nowadays are distributed systems, and these sometimes have to "agree on a value", this is where consensus algorithms come in. In this session we'll look at the general problem and solve a few example cases using the RAFT algorithm implemented using Akka's Actor and Cluster modules.
This document discusses using multiple programming languages to build hybrid web applications. It describes how the author used Google Web Toolkit (GWT) and JavaScript to build applications, but encountered limitations with GWT. It then introduces Dart as an alternative to GWT that allows better integration with JavaScript through an event bridge pattern. This allows building applications with Dart and JavaScript components communicating through JSON messages. The document argues that a hybrid approach allows using the best languages for different application layers and reusing existing JavaScript libraries.
Carlo Sciolla - Above and beyond type systems with clojure.spec - Codemotion ...Codemotion
The most exciting feature of the upcoming Clojure 1.9 is clojure.spec, which delivers a game changer experience in a dynamically typed language such as clojure. With this new tool your code will be able to express constraints that are traditionally very hard to encode in traditional type systems, like describing a function that only accepts a sequence of strings of increasing length of which the third element starts with a capital letter. In this talk I'll start with the spec basics up to some of its advanced usages, from data validation to generative testing.
Getting started with JavaScript can be somewhat challenging. Especially given how fast the scenery changes. In this presentation I provide a general view of the state of the art. Besides this I go through various JavaScript related tricks that I've found useful in practice.
survivejs.com is a companion site of the presentation and goes on further detail in various topics.
The original presentation was given at AgileJkl, a local agile conference held in Central Finland.
MongoDB World 2018: Tutorial - Got Dibs? Building a Real-Time Bidding App wit...MongoDB
This document provides instructions for setting up a real-time bidding app that uses change streams in MongoDB. It includes steps to:
1. Install prerequisites like MongoDB and Node.js.
2. Create the server including setting up MongoDB, creating API endpoints, and connecting the server to MongoDB.
3. Create the client including making a request to the server API to fetch all documents and render them.
It then outlines future steps to add functionality for placing bids in real-time using change streams. The source code provided includes TODO comments to guide completing the implementation.
Nodejs Event Driven Concurrency for Web ApplicationsGanesh Iyer
We describe the event-driven concurrency model used by Nodejs, a JavaScript server-side scripting platform. An overview of the traditional thread based approach(used by Apache) is also given. We compare both the approaches. An Introduction to Nodejs programming is provided and some useful packages are discussed.
This document provides an introduction to NodeJS for beginners. It discusses what NodeJS is, how it uses non-blocking I/O and event-driven architecture, and how to set up NodeJS. It also covers global objects, modules, asynchronous vs synchronous code, core NodeJS modules like filesystem and events, and how to create a basic "Hello World" NodeJS application.
Nobody likes to wait for web pages to load in the browser. The longer it takes, the more dissatisfied the users become. Slow web pages lead to a higher bounce rate and the loss of customers. To solve this kind of problems can be very hard sometimes. Before you even start to optimise your page, you have to understand the workflows a browser performs in order to display a page on the screen. In this talk you will get some insights in the critical rendering path and the javascript engine of your browser that help you to find performance problems and solve them. I will show you also some tools and best practices that make your life easier when it comes to performance.
This document discusses microservices using Node.js and JavaScript. It covers building an HTTP microservice with Express including routing, structure, database integration, logging and testing. It also discusses building command-based microservices with Seneca including patterns, plugins, and queueing. Finally, it discusses containerization with Docker, API gateways, testing, process management with PM2, and some considerations around when microservices may not be the best solution.
Decompose That WAR! Architecting for Adaptability, Scalability, and Deployabi...Chris Richardson
It’s no longer acceptable to develop large, monolithic, single-language, single-framework Web applications. In this session, you will learn how to use the scale cube to decompose your monolithic Web application into a set of narrowly focused, independently deployable services. The presentation discusses how a modular architecture makes it easy to adopt newer and better languages and technologies. You will learn about the various communication mechanisms—synchronous and asynchronous—that these services can use.
The document discusses JavaScript internals such as scope, closures, prototypes and classes. It explains how scope works in JavaScript and how closures allow functions to access outer scope even when executed outside of it. It also compares prototypical inheritance to classical inheritance in JavaScript and how ES2015 classes provide syntactic sugar for prototypical inheritance with the ability to reference super classes.
This document provides an overview of the MEAN stack and its components. It discusses Node.js and its asynchronous and non-blocking architecture. It introduces MongoDB for data storage. It also covers Express, a web application framework for Node.js, and Angular 2, a front-end framework. Code examples and demos are provided for Node.js, Express, MongoDB integration, and building an Angular 2 application. The document is intended to educate developers on the MEAN stack technologies.
The modern web is feature-rich and fast, and Dart gives you a familiar and productive toolchain to scale up your code and apps. Come learn what's new with the Dart project, and how you can use the class-based language, rich built-in libraries, productive editor, package manager, and more. You want more? How about Web Components and a Future-based DOM! You'll see lots of demos, with special attention to the Dart-to-JavaScript compiler.
Web pages can get very complex and slow. In this talk, I share how we solve some of these problems at LinkedIn by leveraging composition and streaming in the Play Framework. This was my keynote for Ping Conference 2014 ( http://www.ping-conf.com/ ): the video is on ustream ( http://www.ustream.tv/recorded/42801129 ) and the sample code is on github ( https://github.com/brikis98/ping-play ).
If you have ever wanted to code an application with Angular this is your chance. Join us for a fun filled day of learning Angular in this hands-on workshop. You will go from 0 to 60 with your Angular knowledge and be able to create our own Angular applications by the end of this workshop. We will start with a new project and continue to build up the project until we have a full application at the end.
This document contains the slides from a talk given by Konrad Malawski on the "Tao/Zen of Programming" using Akka. Some of the key points discussed include:
- Actors are meant to work together and each actor should focus on a single responsibility. Having only one actor limits its capabilities.
- Actors should be structured in a hierarchy with parent-child relationships to allow for supervision. Actors should also be named meaningfully based on their purpose.
- Blocking operations can starve other actors by monopolizing shared resources. Blocking code needs to be isolated on dedicated dispatchers.
- Messages should be processed asynchronously using for/flatMap instead of awaiting futures to avoid blocking
Lucio Grenzi - Building serverless applications on the Apache OpenWhisk platf...Codemotion
Apache OpenWhisk provides a powerful and flexible environment for deploying cloud-native applications driven by data, message, and API call events. We will show how and why we integrated Apache OpenWhisk and GitHub to make deployment as easy and transparent as `git push`. We will also discuss the benefit of using an open source cloud platform and explain how serverless allows developers to focus on writing value-adding code.
Ruby is designed to make programmers happy by providing simplicity, openness, and an object-oriented yet dynamic programming experience. It aims to focus on humans rather than machines. Ruby promotes productivity through conventions that speed development and testing. Programmers enjoy coding in Ruby due to its immediate feedback and morale boost. Ruby has broad utility across web, text, and GUI applications and is platform agnostic, running on most operating systems.
Node.js is a lightweight but yet capable platform for creating powerful web applications. The core of Node.js is kept small and restricted to a limited functionality that is extended by a vast ecosystem. With the right combination of packages you are able to build full-featured web applications. There is nearly no limit in features starting with simple problems such as authentication or logging over web interfaces with REST or GraphQL to a whole application based on a microservices architecture. In this talk I will introduce you to some commonly used packages and show you how to use them by example.
React Native allows developers to build native mobile apps using JavaScript and React. While it provides benefits like using React for both web and mobile, allowing for code reuse, there are also challenges to using it in production. It is easy for web developers to use initially but documentation is poor and updates can cause breaking changes. Performance has not been an issue yet but native apps are generally faster. While the community is active, third party packages can introduce bugs and the build can sometimes break, especially on Android. Overall, React Native can be used for production apps if challenges around updates and crashes are addressed.
Matteo Manchi - React Native for multi-platform mobile applications - Codemot...Codemotion
Since its 2013 release, React has brought a new way to design UI components in the world wide web. The same fundamentals have been taken to another important environment in our contemporary world: the mobile applications. We'll see the philosophy behind React Native - learn once, write anywhere - and how this new framework helps developers to build native apps using React.
Distributed Consensus A.K.A. "What do we eat for lunch?"Konrad Malawski
Distributed Consensus is everywhere! Even if not obvious at first, most apps nowadays are distributed systems, and these sometimes have to "agree on a value", this is where consensus algorithms come in. In this session we'll look at the general problem and solve a few example cases using the RAFT algorithm implemented using Akka's Actor and Cluster modules.
This document discusses using multiple programming languages to build hybrid web applications. It describes how the author used Google Web Toolkit (GWT) and JavaScript to build applications, but encountered limitations with GWT. It then introduces Dart as an alternative to GWT that allows better integration with JavaScript through an event bridge pattern. This allows building applications with Dart and JavaScript components communicating through JSON messages. The document argues that a hybrid approach allows using the best languages for different application layers and reusing existing JavaScript libraries.
Carlo Sciolla - Above and beyond type systems with clojure.spec - Codemotion ...Codemotion
The most exciting feature of the upcoming Clojure 1.9 is clojure.spec, which delivers a game changer experience in a dynamically typed language such as clojure. With this new tool your code will be able to express constraints that are traditionally very hard to encode in traditional type systems, like describing a function that only accepts a sequence of strings of increasing length of which the third element starts with a capital letter. In this talk I'll start with the spec basics up to some of its advanced usages, from data validation to generative testing.
Getting started with JavaScript can be somewhat challenging. Especially given how fast the scenery changes. In this presentation I provide a general view of the state of the art. Besides this I go through various JavaScript related tricks that I've found useful in practice.
survivejs.com is a companion site of the presentation and goes on further detail in various topics.
The original presentation was given at AgileJkl, a local agile conference held in Central Finland.
MongoDB World 2018: Tutorial - Got Dibs? Building a Real-Time Bidding App wit...MongoDB
This document provides instructions for setting up a real-time bidding app that uses change streams in MongoDB. It includes steps to:
1. Install prerequisites like MongoDB and Node.js.
2. Create the server including setting up MongoDB, creating API endpoints, and connecting the server to MongoDB.
3. Create the client including making a request to the server API to fetch all documents and render them.
It then outlines future steps to add functionality for placing bids in real-time using change streams. The source code provided includes TODO comments to guide completing the implementation.
Nodejs Event Driven Concurrency for Web ApplicationsGanesh Iyer
We describe the event-driven concurrency model used by Nodejs, a JavaScript server-side scripting platform. An overview of the traditional thread based approach(used by Apache) is also given. We compare both the approaches. An Introduction to Nodejs programming is provided and some useful packages are discussed.
This document provides an introduction to NodeJS for beginners. It discusses what NodeJS is, how it uses non-blocking I/O and event-driven architecture, and how to set up NodeJS. It also covers global objects, modules, asynchronous vs synchronous code, core NodeJS modules like filesystem and events, and how to create a basic "Hello World" NodeJS application.
NodeJS: the good parts? A skeptic’s view (devnexus2014)Chris Richardson
JavaScript used to be confined to the browser. But these days, it becoming increasingly popular in server-side applications in the form of NodeJS. NodeJS provides event-driven, non-blocking I/O model that supposedly makes it easy to build scalable network application.
In this talk you will learn about the consequences of combining the event-driven programming model with a prototype-based, weakly typed, dynamic language. We will share our perspective as a server-side Java developer who wasn’t entirely happy about JavaScript in the browser, let alone on the server. You will learn how to use NodeJS effectively in modern, polyglot applications.
NodeJS for Novices - 28/Oct/13 - Winnipeg, MBDavid Wesst
The document is a presentation by David Wesst introducing Node.js. It begins with background on Wesst and sets the point of answering questions about Node.js. The presentation plan is to explain what Node.js is, how to set it up, key tools like NPM, and how to start coding with callbacks and modules. Key aspects of Node.js covered include it being server-side JavaScript, using asynchronous and non-blocking I/O, and how it differs from ASP.NET by being open source and not requiring IIS. Examples are provided of using NPM, coding with callbacks, and making modules.
NodeJS is an open-source and cross-platform JavaScript runtime environment that allows JavaScript to be used for server-side scripting. The document discusses what NodeJS is, why it was created, how to use it, who uses it, and its use in China (CNodeJS). Key points are that NodeJS is used for building scalable network applications using non-blocking I/O and the JavaScript language, and that it has seen significant adoption in China from companies like Taobao and Sina for building web servers and real-time applications.
Node.js is an open-source JavaScript runtime environment that allows building scalable server-side and networking applications. It uses asynchronous, event-driven, non-blocking I/O which makes it lightweight and efficient for data-intensive real-time applications that run across distributed devices. Some key features of Node.js include excellent support for building RESTful web services, real-time web applications, IoT applications and scaling to many users. It uses Google's V8 JavaScript engine to execute code outside of a browser.
The document discusses security best practices for Node.js applications. It covers using packages like Helmet to set secure HTTP headers, encrypting sessions with packages like cookie-session, preventing XSS attacks with csurf, sanitizing user input with express-validator, and encrypting passwords with bcrypt. It also discusses building secure HTTPS servers, analyzing dependencies for vulnerabilities with tools like NSP and Snyk, and using the Node Goat project to intentionally introduce vulnerabilities for testing security.
NodeJS: the good parts? A skeptic’s view (jax jax2013)Chris Richardson
JavaScript used to be confined to the browser. But these days, it's becoming increasingly popular in server-side applications in the form of Node.js. Node.js provides event-driven, non-blocking I/O model that supposedly makes it easy to build scalable network application. In this talk you will learn about the consequences of combining the event-driven programming model with a prototype-based, weakly typed, dynamic language. We will share our perspective as a server-side Java developer who wasn’t entirely happy about JavaScript in the browser, let alone on the server. You will learn how to use Node.js effectively in modern, polyglot applications.
Watch the video: http://www.youtube.com/watch?v=CN0jTnSROsk&feature=youtu.be
Asynchronous programming done right - Node.jsPiotr Pelczar
This document discusses asynchronous programming and avoiding race conditions. It covers how asynchronous actions allow the main program flow to continue processing without blocking on I/O. It also discusses how asynchronous programming works with callbacks and promises rather than sequential execution. It provides examples of using libraries like Async to control asynchronous flows and common pitfalls to avoid like double callbacks and unexpected asynchronous behavior.
An introduction to developing with Node.js and some useful tools to help the development and deployment processes. This talk was given at Asyncjs in Brighton
http://asyncjs.com/intro-nodejs
Data Streaming with Apache Kafka & MongoDB - EMEAAndrew Morgan
A new generation of technologies is needed to consume and exploit today's real time, fast moving data sources. Apache Kafka, originally developed at LinkedIn, has emerged as one of these key new technologies.
This webinar explores the use-cases and architecture for Kafka, and how it integrates with MongoDB to build sophisticated data-driven applications that exploit new sources of data.
This document provides an introduction and overview to building server-side APIs with Node.js and the Express framework. It begins with an agenda that covers the basics of Node.js, concepts like HTTP and the module system, and then introduces Express as a web framework for Node.js. Several code examples are provided to demonstrate basic Express routing and handling HTTP requests.
Vefurinn hefur á undanförnum árum náð fótfestu sem sjálfgefið viðmót á hugbúnaði. Enterprise lausnir hafa gjarnan vefviðmót, bæði fyrir viðskiptavini og starfsmenn. Á síðari árum hafa snjallsímalaunsir bæst við. Við það hefur orðið skýrari skil milli viðmóts og bakenda, með forritaskilum - API.
Í þessum fyrirlestri skoðum við framsetningarlagið - Presentation Layer Design og hvernig við getum hannað forrit fyrir þetta lag. Skoðuð eru ýmis munstur og það helsta er eitt það frægasta í hugbúnaðargerð: Model View Controller.
Við skoðum einnig Play framework en það er ramminn sem við notum til að forrita.
Alphorm.com Formation NodeJS, les fondamentauxAlphorm
Formation complète ici :
http://www.alphorm.com/tutoriel/formation-en-ligne-nodejs-les-fondamentaux
Node.Js a complètement révolutionné la perception de JavaScript et l’architecture logicielle côté serveur. NodeJS est très performant, agréable à l’emploi, doté d’un écosystème et d’une communauté riche et réactive. Très adapté et adopté pour des applications en production avec une montée en charge importante.
Cette formation Node.js vous donne toutes les clés pour bien démarrer avec Node.js tout en suivant les bonnes pratiques grâce à l'expertise de votre formateur NodeJS Edouard FERRARI.
Durant cette formation NodeJS, vous allez apprendre à développer des applications réactives et performantes avec Node.js. Vous mettrez en œuvre les concepts de programmation événementielle et asynchrone, de modularité avec des modules natifs très puissants.
A travers cette formation NodeJS vous allez pouvoir développer en quelques heures une application dont il aurait fallu plusieurs semaines de travail avec des langages plus classiques (C, C++, Java, …).Evidemment les sources de cette application sont téléchargeables depuis votre espace membre.
Powering Microservices with MongoDB, Docker, Kubernetes & Kafka – MongoDB Eur...Andrew Morgan
Organisations are building their applications around microservice architectures because of the flexibility, speed of delivery, and maintainability they deliver.
Want to try out MongoDB on your laptop? Execute a single command and you have a lightweight, self-contained sandbox; another command removes all trace when you're done. Need an identical copy of your application stack in multiple environments? Build your own container image and then your entire development, test, operations, and support teams can launch an identical clone environment.
Containers are revolutionizing the entire software lifecycle: from the earliest technical experiments and proofs of concept through development, test, deployment, and support. Orchestration tools manage how multiple containers are created, upgraded and made highly available. Orchestration also controls how containers are connected to build sophisticated applications from multiple, microservice containers.
This presentation introduces you to technologies such as Docker, Kubernetes & Kafka which are driving the microservices revolution. Learn about containers and orchestration – and most importantly how to exploit them for stateful services such as MongoDB.
This document provides an introduction to Node.js. It discusses why JavaScript can be strange, but explains that JavaScript is relevant as the language of the web. It then discusses what Node.js is and its event-driven, non-blocking architecture. Popular Node.js applications like HTTP servers, REST APIs, and web sockets are mentioned. Examples are provided of building a simple web app with Express and Jade, a REST API with Restify, and using web sockets with Socket.io. The document also discusses using Mongoose with MongoDB for data modeling.
Futures and Rx Observables: powerful abstractions for consuming web services ...Chris Richardson
A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone.
In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.
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.
The curious Life of JavaScript - Talk at SI-SE 2015jbandi
My talk about the life of JavaScript, from birth to today.
I went trough the demos and code examples very quickly, rather as a teaser to show how modern JavaScript development might look.
If you are interested in a deep dive into the topic of modern JavaScript development, HTML5, ES6, AngularJS, React, Gulp, Grunt etc, please consider my courses: http://www.ivorycode.com/#schulung
Map, Flatmap and Reduce are Your New Best Friends: Simpler Collections, Concu...Chris Richardson
Higher-order functions such as map(), flatmap(), filter() and reduce() have their origins in mathematics and ancient functional programming languages such as Lisp. But today they have entered the mainstream and are available in languages such as JavaScript, Scala and Java 8. They are well on their way to becoming an essential part of every developer’s toolbox.
In this talk you will learn how these and other higher-order functions enable you to write simple, expressive and concise code that solve problems in a diverse set of domains. We will describe how you use them to process collections in Java and Scala. You will learn how functional Futures and Rx (Reactive Extensions) Observables simplify concurrent code. We will even talk about how to write big data applications in a functional style using libraries such as Scalding.
This document discusses the author's work on building interactive programming environments directly in the browser. It summarizes that the author dreamed of a portable browser-based REPL (read-eval-print loop) and created http://repl.it which supports 17 programming languages in the browser using a JavaScript library. It also discusses how JavaScript has become an accidental web virtual machine that many other languages compile to.
Deploying Spring Boot applications with Docker (east bay cloud meetup dec 2014)Chris Richardson
This presentation describes how to deploy a Spring Boot-based microservice using Docker.
See http://plainoldobjects.com/2014/11/16/deploying-spring-boot-based-microservices-with-docker/
This document discusses JavascriptMVC, an alternative Javascript MVC framework to BackboneJS. It provides an overview of JavascriptMVC's features such as MIT licensing, clear documentation, and providing an almost total solution for building web applications. Potential pros include the licensing, documentation, and comprehensive features. Potential cons include it being less well known and having fewer online resources than BackboneJS in Taiwan. Examples of how it handles classes, CSS, data loading/validation, and views are also provided.
This document provides an introduction and overview of a Node.js tutorial presented by Tom Hughes-Croucher. The tutorial covers topics such as building scalable server-side code with JavaScript using Node.js, debugging Node.js applications, using frameworks like Express.js, and best practices for deploying Node.js applications in production environments. The tutorial includes exercises for hands-on learning and demonstrates tools and techniques like Socket.io, clustering, error handling and using Redis with Node.js applications.
Davide Cerbo - Kotlin loves React - Codemotion Milan 2018Codemotion
Kotlin è un linguaggio basato sulla JVM che si sta sviluppando molto rapidamente. Ma il suo scopo non è solo conquistare la JVM, ma ogni piattaforma. Durante il talk vedremo come sviluppare una applicazione web utilizzando React e Kotlin e analizzeremo quali sono i vantaggi di usare un linguaggio staticamente tipizzato nello sviluppo frontend.
The document provides an overview of Node.js, a JavaScript runtime environment for building scalable network applications. Some key points covered include:
- Node.js is built on Google's V8 JavaScript engine and is event-driven and non-blocking.
- It is well-suited for data-intensive real-time applications due to its lightweight and efficient nature.
- Node.js differs from other scripting languages by being non-blocking, single-threaded, and having an event-based approach built-in.
An overview of our experiments at Industrial Light and Magic to create a fully cloud based pipeline, based on Mesos, Docker and automated with Ansible.
Construction Techniques For Domain Specific LanguagesThoughtWorks
The document discusses techniques for constructing domain-specific languages (DSLs). It describes how DSLs can be implemented using method chaining to allow fluent interfaces that transform types and relay instruction context across method calls. It provides examples of literal extension where methods are added to program literals, nested closures to express semantic models, and method chaining to mimic expected behaviors. The key messages are that DSLs are languages defined for a particular domain, should be declarative, know their audience, and keep the underlying domain model clean.
Integrating React.js Into a PHP ApplicationAndrew Rota
React.js has taken the web development world by storm, and for good reason: React offers a declarative, component-oriented approach to building highly-scalable web UIs. But how can we take advantage of a JavaScript library like React in our server-side PHP applications. In this talk l cover the different ways React.js can be integrated into an existing PHP web application: from a client-side only approach to multiple techniques that support full server-side rendering with a Node.js server or PHP’s v8js. I also discuss the trade-offs in each of these designs and the challenges involved with adding React to a PHP site. Most importantly, I consider the higher-level issue of how to improve view cohesion across the client-server divide in a PHP application.
Bringing your app to the web with Dart - Chris Buckett (Entity Group)jaxLondonConference
Presented at JAX London 2013
Building complex applications in the browser is hard especially when you are working in teams. Dart is ideal for developing the next generation of web applications in an enterprise environment, by allowing you to communicate type information to your fellow developers and automated tools. With familiar (but lightweight) syntax, class-based OOP and a type system that allows tooling, Java developers will quickly feel at home with Dart.
This document summarizes the key lessons learned from converting a legacy robotics project from Objective-C to Swift. It discusses issues with the original Objective-C code like silent nil failures, weak type safety with NSCoding, and problems with error handling. The document then covers how Swift addresses these issues through features like optional values, type safety, value types, and improved error handling with enums, throws, and do-catch. Overall, converting to Swift reduced the code base size by 75%, removed classes of bugs, found subtle bugs earlier, and allowed new features by making the code more robust.
Real World Lessons on the Pain Points of Node.JS ApplicationBen Hall
This document provides lessons learned from real world experiences with Node.js applications. It discusses the importance of upgrading to newer Node.js versions for security and features. It also emphasizes the importance of error handling, using promises for async flow control, and scaling applications using Docker containers. Debugging and monitoring Node.js applications for performance is also covered.
Cleaning your architecture with android architecture componentsDebora Gomez Bertoli
This document discusses cleaning up Android architecture using Architecture Components. It begins with an overview of issues with previous approaches like callbacks between layers. It then covers how each component addresses these issues: ViewModel/LiveData for presentation, MediatorLiveData for merging repository calls in the domain layer, and Room/Paging Library for the data layer. Considerations are provided for each component regarding threading, lifecycles, and other best practices. Code examples demonstrate implementations across the layers following these guidelines.
This document discusses KrakenJS, an open source JavaScript framework built on Node.js and Express. It summarizes PayPal's transition from Java to Node.js architectures to enable faster development and deployment cycles. It then describes the major components of KrakenJS, including Makara for internationalization, Lusca for security, Adaro for templating with Dust, and a generator for setting up new KrakenJS apps. The use of these components for templating, configuration, and model generation is also outlined.
The document introduces the Play Framework version 2.1 and highlights its key features. It demonstrates building a sample application in Scala using Play's reactive, non-blocking architecture. Key features discussed include Play's built-in support for Scala, reactive programming, JSON APIs, routing, templates, and testing.
Building with Watson - Serverless Chatbots with PubNub and ConversationIBM Watson
This document discusses building serverless chatbots using PubNub and IBM Watson Conversation. It introduces PubNub BLOCKS as a way to run serverless JavaScript functions. It then demonstrates three chatbots built with these technologies: a heart emoji replacing bot, an image processing bot, and a music trivia bot that uses Watson APIs. The document emphasizes using serverless architectures and stateless AI microservices with context stored in the network to build scalable chatbots.
Similar to NodeJS: the good parts? A skeptic’s view (oredev, oredev2013) (20)
A common microservice architecture anti-pattern is more the merrier. It occurs when an organization team builds an excessively fine-grained architecture, e.g. one service-per-developer. In this talk, you will learn about the criteria that you should consider when deciding service granularity. I'll discuss the downsides of a fine-grained microservice architecture. You will learn how sometimes the solution to a design problem is simply a JAR file.
YOW London - Considering Migrating a Monolith to Microservices? A Dark Energy...Chris Richardson
This is a talk I gave at YOW! London 2022.
Let's imagine that you are responsible for an aging monolithic application that's critical to your business. Sadly, getting changes into production is a painful ordeal that regularly causes outages. And to make matters worse, the application's technology stack is growing increasingly obsolete. Neither the business nor the developers are happy. You need to modernize your application and have read about the benefits of microservices. But is the microservice architecture a good choice for your application?
In this presentation, I describe the dark energy and dark matter forces (a.k.a. concerns) that you must consider when deciding between the monolithic and microservice architectural styles. You will learn about how well each architectural style resolves each of these forces. I describe how to evaluate the relative importance of each of these forces to your application. You will learn how to use the results of this evaluation to decide whether to migrate to the microservice architecture.
Dark Energy, Dark Matter and the Microservices Patterns?!Chris Richardson
Dark matter and dark energy are mysterious concepts from astrophysics that are used to explain observations of distant stars and galaxies. The Microservices pattern language - a collection of patterns that solve architecture, design, development, and operational problems — enables software developers to use the microservice architecture effectively. But how could there possibly be a connection between microservices and these esoteric concepts from astrophysics?
In this presentation, I describe how dark energy and dark matter are excellent metaphors for the competing forces (a.k.a. concerns) that must be resolved by the microservices pattern language. You will learn that dark energy, which is an anti-gravity, is a metaphor for the repulsive forces that encourage decomposition into services. I describe how dark matter, which is an invisible matter that has a gravitational effect, is a metaphor for the attractive forces that resist decomposition and encourage the use of a monolithic architecture. You will learn how to use the dark energy and dark matter forces as guide when designing services and operations.
Dark energy, dark matter and microservice architecture collaboration patternsChris Richardson
Dark energy and dark matter are useful metaphors for the repulsive forces, which encourage decomposition into services, and the attractive forces, which resist decomposition. You must balance these conflicting forces when defining a microservice architecture including when designing system operations (a.k.a. requests) that span services.
In this talk, I describe the dark energy and dark matter forces. You will learn how to design system operations that span services using microservice architecture collaboration patterns: Saga, Command-side replica, API composition, and CQRS patterns. I describe how each of these patterns resolve the dark energy and dark matter forces differently.
It sounds dull but good architecture documentation is essential. Especially when you are actively trying to improve your architecture.
For example, I spend a lot time helping clients modernize their software architecture. More often than I like, I’m presented with a vague and lifeless collection of boxes and lines. As a result, it’s sometimes difficult to discuss the architecture in a meaningful and productive way. In this presentation, I’ll describe techniques for creating minimal yet effective documentation for your application’s microservice architecture. In particular, you will learn how documenting scenarios can bring your architecture to life.
Using patterns and pattern languages to make better architectural decisions Chris Richardson
This is a presentation that gave at the O'Reilly Software Architecture Superstream: Software Architecture Patterns.
The talk's focus is the microservices pattern language.
However, it also shows how thinking with the pattern mindset - context/problem/forces/solution/consequences - leads to better technically decisions.
The microservices architecture offers tremendous benefits, but it’s not a silver bullet. It also has some significant drawbacks. The microservices pattern language—a collection of patterns that solve architecture, design, development, and operational problems—enables software developers to apply the microservices architecture effectively. I provide an overview of the microservices architecture and examines the motivations for the pattern language, then takes you through the key patterns in the pattern language.
Rapid, reliable, frequent and sustainable software development requires an architecture that is loosely coupled and modular.
Teams need to be able complete their work with minimal coordination and communication with other teams.
They also need to be able keep the software’s technology stack up to date.
However, the microservice architecture isn’t always the only way to satisfy these requirements.
Yet, neither is the monolithic architecture.
In this talk, I describe loose coupling and modularity and why they are is essential.
You will learn about three architectural patterns: traditional monolith, modular monolith and microservices.
I describe the benefits, drawbacks and issues of each pattern and how well it supports rapid, reliable, frequent and sustainable development.
You will learn some heuristics for selecting the appropriate pattern for your application.
Events to the rescue: solving distributed data problems in a microservice arc...Chris Richardson
To deliver a large complex application rapidly, frequently and reliably, you often must use the microservice architecture.
The microservice architecture is an architectural style that structures the application as a collection of loosely coupled services.
One challenge with using microservices is that in order to be loosely coupled each service has its own private database.
As a result, implementing transactions and queries that span services is no longer straightforward.
In this presentation, you will learn how event-driven microservices address this challenge.
I describe how to use sagas, which is an asynchronous messaging-based pattern, to implement transactions that span services.
You will learn how to implement queries that span services using the CQRS pattern, which maintain easily queryable replicas using events.
A pattern language for microservices - June 2021 Chris Richardson
The microservice architecture is growing in popularity. It is an architectural style that structures an application as a set of loosely coupled services that are organized around business capabilities. Its goal is to enable the continuous delivery of large, complex applications. However, the microservice architecture is not a silver bullet and it has some significant drawbacks.
The goal of the microservices pattern language is to enable software developers to apply the microservice architecture effectively. It is a collection of patterns that solve architecture, design, development and operational problems. In this talk, I’ll provide an overview of the microservice architecture and describe the motivations for the pattern language. You will learn about the key patterns in the pattern language.
QConPlus 2021: Minimizing Design Time Coupling in a Microservice ArchitectureChris Richardson
Delivering large, complex software rapidly, frequently and reliably requires a loosely coupled organization. DevOps teams should rarely need to communicate and coordinate in order to get work done. Conway's law states that an organization and the architecture that it develops mirror one another. Hence, a loosely coupled organization requires a loosely coupled architecture.
In this presentation, you will learn about design-time coupling in a microservice architecture and why it's essential to minimize it. I describe how to design service APIs to reduce coupling. You will learn how to minimize design-time coupling by applying a version of the DRY principle. I describe how key microservices patterns potentially result in tight design time coupling and how to avoid it.
Mucon 2021 - Dark energy, dark matter: imperfect metaphors for designing micr...Chris Richardson
In order to explain certain astronomical observations, physicists created the mysterious concepts of dark energy and dark matter.
Dark energy is a repulsive force.
It’s an anti-gravity that is forcing matter apart and accelerating the expansion of the universe.
Dark matter has the opposite attraction effect.
Although it’s invisible, dark matter has a gravitational effect on stars and galaxies.
In this presentation, you will learn how these metaphors apply to the microservice architecture.
I describe how there are multiple repulsive forces that drive the decomposition of your application into services.
You will learn, however, that there are also multiple attractive forces that resist decomposition and bind software elements together.
I describe how as an architect you must find a way to balance these opposing forces.
Skillsmatter CloudNative eXchange 2020
The microservice architecture is a key part of cloud native.
An essential principle of the microservice architecture is loose coupling.
If you ignore this principle and develop tightly coupled services the result will mostly likely be yet another "microservices failure story”.
Your application will be brittle and have all of disadvantages of both the monolithic and microservice architectures.
In this talk you will learn about the different kinds of coupling and how to design loosely coupled microservices.
I describe how to minimize design time and increase the productivity of your DevOps teams.
You will learn how how to reduce runtime coupling and improve availability.
I describe how to improve availability by minimizing the coupling caused by your infrastructure.
DDD SoCal: Decompose your monolith: Ten principles for refactoring a monolith...Chris Richardson
This is a talk I gave at DDD SoCal.
1. Make the most of your monolith
2. Adopt microservices for the right reasons
3. It’s not just architecture
4. Get the support of the business
5. Migrate incrementally
6. Know your starting point
7. Begin with the end in mind
8. Migrate high-value modules first
9. Success is improved velocity and reliability
10. If it hurts, don’t do it
Decompose your monolith: Six principles for refactoring a monolith to microse...Chris Richardson
This was a talk I gave at the CTO virtual summit on July 28th. It describes 6 principles for refactoring to a microservice architecture.
1. Make the most of your monolith
2. Adopt microservices for the right reasons
3. Migrate incrementally
4. Begin with the end in mind
5. Migrate high-value modules first
6. Success is improved velocity and reliability
The microservice architecture is becoming increasingly important. But what is it exactly? Why should you care about microservices? And, what do you need to do to ensure that your organization uses the microservice architecture successfully? In this talk, I’ll answer these and other questions. You will learn about the motivations for the microservice architecture and why simply adopting microservices is insufficient. I describe essential characteristics of microservices, You will learn how a successful microservice architecture consists of loosely coupled services with stable APIs that communicate asynchronously.
This document discusses strategies for migrating a monolithic application to microservices. It begins with an overview of decomposing a monolith and implementing new features as microservices. It then provides an example of extracting the delivery module from a monolithic food delivery application into its own delivery microservice. The example outlines the steps of splitting the code, extracting the relevant database tables, defining and deploying the new delivery service, integrating it with the monolith, and removing the old code. Finally, it discusses implementing a delayed delivery service as another example.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Best 20 SEO Techniques To Improve Website Visibility In SERPPixlogix Infotech
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
HCL Notes and Domino License Cost Reduction in the World of DLAU
NodeJS: the good parts? A skeptic’s view (oredev, oredev2013)
1. NodeJS: the good parts?
A skeptic’s view
Chris Richardson
Author of POJOs in Action
Founder of the original CloudFoundry.com
@crichardson
chris@chrisrichardson.net
http://plainoldobjects.com
@crichardson
2. Presentation goal
How a grumpy, gray-haired
server-side Java developer
discovered an appreciation
for NodeJS and JavaScript
@crichardson
8. Agenda
Overview of NodeJS
JavaScript: Warts and all
The Reactor pattern: an event-driven architecture
NodeJS: There is a module for that
Building a front-end server with NodeJS
@crichardson
14. Dynamic and weakly-typed
Dynamic:
Types are associated with values - not variables
Define new program elements at runtime
Weakly typed:
Leave out arguments to methods
Read non-existent object properties
Add new properties by simply setting them
@crichardson
16. JavaScript is a prototypal
language
Person
__proto__
sayHello
...
Prototype
function
...
inherited
Chris __proto__
name
nickname
“Chris”
“CER”
overrides
object specific
@crichardson
17. Prototypal code
Not defined
here
$ node
> var person = { sayHello: function () { console.log("Hello " + this.name); }};
[Function]
> var chris = Object.create(person, {name: {value: "Chris"}});
undefined
> var sarah = Object.create(person, {name: {value: "Sarah"}});
undefined
> chris.sayHello();
Hello Chris
create using
undefined
properties
> sarah.sayHello();
prototype
Hello Sarah
undefined
> chris.sayHello = function () { console.log("Hello mate: " + this.name); };
[Function]
> chris.sayHello();
Hello mate: Chris
undefined
@crichardson
18. JavaScript is Functional
function makeGenerator(nextFunction) {
Return a function
closure
var value = 0;
return function() {
var current = value;
value = nextFunction(value);
return current;
};
Pass function as an
argument
}
var inc = makeGenerator(function (x) {return x + 1; });
> inc()
0
> inc()
1
@crichardson
19. But JavaScript was created
in a hurry
The ‘Java...’ name creates expectations that it can’t satisfy
Fake classes: Hides prototypes BUT still seems weird
global namespace
scope of vars is confusing
Missing return statement = confusion
‘function’ is really verbose
‘this’ is dynamically scoped
Unexpected implicit conversions: 99 == “99”!
truthy and falsy values
52-bit ints
@crichardson
20. Dynamic + weakly-typed (+ event-driven)
code
+
misspelt property names
lots of time spent in the abyss
Essential: Use IDE integrated
with JSLint/JSHint + tests
21. Prototypal languages have
benefits BUT
Developers really like classes
JavaScript prototypes lack the powerful features from
the Self language
e.g. Multiple (and dynamic) inheritance
http://www.cs.ucsb.edu/~urs/oocsb/self/papers/papers.html
@crichardson
22. Verbose function syntax
> var numbers = [1,2,3,4,5]
> numbers.filter(function (n) { return n % 2 == 0; } ).map(function (n) { return n * n; })
[ 4, 16 ]
>
Versus
Prelude> let numbers = [1,2,3,4,5]
Prelude> map (n -> n * n) (filter (n -> mod n 2 == 0) numbers)
[4,16]
Or
scala> val numbers = 1..5
scala> numbers filter { _ % 2 == 0} map { n => n * n }
Vector(4, 16)
@crichardson
23. Verbose DSLs
describe('SomeEntity', function () {
beforeEach(function () { ... some initialization ... });
Jasmine
it('should do something', function () {
...
expect(someExpression).toBe(someValue);
});
});
Versus
class SomeScalaTest ...{
Scalatest
before { ... some initialization ... }
it should "do something" in {
...
someExpression should be(someValue)
}
@crichardson
24. JavaScript is the language
of the web
“You have to use the programming
language you have, not the one that you
might want”
@crichardson
25. It works but the result is
lost opportunities
and
impeded progress
@crichardson
26. Martin Fowler once said:
"...I'm one of those who despairs that a
language with such deep flaws plays such an
important role in computation. Still the
consequence of this is that we must take
javascript seriously as a first-class language
and concentrate on how to limit the damage
its flaws cause. ...."
http://martinfowler.com/bliki/gotoAarhus2012.html
@crichardson
27. Use just the good parts
Douglas
Crockford
http://www.crockford.com/
@crichardson
28. Use a language that
compiles to JavaScript
TypeScript
Classes and interfaces (dynamic structural typing)
Typed parameters and fields
Dart
Class-based OO
Optional static typing
Bidirectional binding with DOM elements
Less backwards compatibility with JavaScript
Also has it’s own VM
@crichardson
29. CoffeeScript Hello World
Classes :-)
http = require('http')
Concise
class HttpRequestHandler
constructor: (@message) ->
Bound method
handle: (req, res) =>
res.writeHead(200, {'Content-Type': 'text/plain'})
res.end(@message + 'n')
handler = new HttpRequestHandler "Hi There from CoffeeScript"
server = http.createServer(handler.handle)
server.listen(1338, '127.0.0.1')
console.log('Server running at http://127.0.0.1:1338/')
@crichardson
32. About the Reactor pattern
Defined by Doug Schmidt in 1995
Pattern for writing scalable servers
Alternative to thread-per-connection model
Single threaded event loop dispatches events on
handles (e.g. sockets, file descriptors) to event handlers
@crichardson
34. Benefits
Separation of concerns - event handlers separated
from low-level mechanism
More efficient - no thread context switching
Simplified concurrency - single threaded = no
possibility of concurrent access to shared state
@crichardson
35. Drawbacks
Non-pre-emptive - handlers must not take a long time
Difficult to understand and debug:
Inverted flow of control
Can’t single step through code easily
Limited stack traces
No stack-based context, e.g. thread locals, exception handlers
How to enforce try {} finally {} behavior?
@crichardson
36. NodeJS app = layers of event
handlers
Recurring
events
from
Event
Emitters
Application code
Event
listener
HTTP
Callback
function
DB driver
...
One time
events:
async
operation
completion
Basic networking/file-system/etc.
NodeJS event loop
@crichardson
37. Async code = callback hell
Scenarios:
Sequential: A
B
C
Scatter/Gather: A and B
C
Code quickly becomes very messy
@crichardson
38. Messy callback code
The result of
getProductDetails
getProductDetails = (productId, callback) ->
productId = req.params.productId
result = {productId: productId}
Propagate error
makeCallbackFor = (key) ->
(error, x) ->
if error
callback(error)
else
result[key] = x
if (result.productInfo and result.recommendations and result.reviews)
callback(undefined, result)
Update result
Gather
getProductInfo(productId, makeCallbackFor('productInfo'))
getRecommendations(productId, makeCallbackFor('recommendations'))
getReviews(makeCallbackFor('reviews'))
Scatter
@crichardson
39. Simplifying code with
Promises (a.k.a. Futures)
Functions return a promise - no callback parameter
A promise represents an eventual outcome
Use a library of functions for transforming and
composing promises
Promises/A+ specification - http://promises-aplus.github.io/promises-spec
when.js (part of cujo.js by SpringSource) is a popular
implementation
Crockford’s RQ library is another option
@crichardson
41. Not bad but lacks Scala’s
syntactic sugar
class ProductDetailsService .... {
def getProductDetails(productId: Long) = {
for (((productInfo, recommendations), reviews) <getProductInfo(productId) zip
getProductInfo(productId) zip
getRecommendations(productId) zip
getRecommendations(productId) zip
getReviews(productId)
getReviews(productId))
yield
ProductDetails(productInfo, recommendations, reviews)
}
}
@crichardson
42. Long running computations
Long running computation
blocks event loop for
other requests
Need to run outside of main event loop
Options:
Community: web workers threads
Built-in: NodeJS child processes
@crichardson
43. Using child processes
parent.js
var child = require('child_process').fork('child.js');
function sayHelloToChild() {
child.send({hello: "child"});
}
Create child process
Send message to child
setTimeout(sayHelloToChild, 1000);
child.on('message', function(m) {
console.log('parent received:', m);
});
function kill() {
child.kill();
}
setTimeout(kill, 2000);
child.js
process.on('message', function (m) {
console.log("child received message=", m);
process.send({ihateyou: "you ruined my life"})
});
@crichardson
44. Modern multi-core machines
vs. single-threaded runtime
Many components of many applications
Don’t need the scalability of the Reactor pattern
Request-level thread-based parallelism works fine
There are other concurrency options
Actors, Software transactional memory, ...
Go goroutines, Erlang processes, ...
Imposing a single-threaded complexity tax on the
entire application is questionable
@crichardson
47. Thousands of community
developed modules
https://npmjs.org/
web frameworks, SQL/NoSQL
database drivers, messaging, utilities...
@crichardson
48. What’s a module?
foo.js
One or more JavaScript files
exports.sayHello = function () {
console.log(“Hello”);
}
Optional native code:
Compiled during installation
JavaScript != systems programming language
Package.json - metadata including dependencies
@crichardson
50. Easy to use
Core module OR
Path to file OR
module in node_modules
Module’s exports
var http = require(“http”)
var server = http.createServer...
@crichardson
52. There is a module for that...
Modules + glue code
=
rapid/easy application development
AWESOME!...
@crichardson
53. ... BUT
Variable quality
Multiple incomplete/competing modules, e.g. MySQL
drivers without connection pooling!
Often abandoned
No notion of a Maven-style local repository/cache =
repeated downloads
...
@crichardson
56. Agenda
Overview of NodeJS
JavaScript: Warts and all
The Reactor pattern: an event-driven architecture
NodeJS: There is a module for that
Building a front-end server with NodeJS
@crichardson
57. So why care about
NodeJS?
Easy to write scalable network services
Easy to push events to the browser
Easy to get (small) stuff done
It has a role to play in modern
application architecture
@crichardson
58. Evolving from a monolithic
architecture....
WAR
StoreFrontUI
Product Info
Service
Recommendation
Service
Review
Service
Order
Service
@crichardson
59. ... to a micro-service architecture
product info application
Product Info
Service
recommendations application
Store front application
StoreFrontUI
Recommendation
Service
reviews application
Review
Service
orders application
Order
Service
@crichardson
61. ...Presentation layer evolution
Browser
View
Web application
Static
content
Controller
JSON-REST
Model
HTML 5/JavaScript
IOS/Android clients
Events
RESTful
Endpoints
Event
publisher
@crichardson
62. Directly connecting the front-end to the backend
Chatty API
View
REST
Product Info
service
REST
Recommendation
Service
AMQP
Controller
Review
service
Model
Traditional web
application
View
Controller
Model
Browser/Native App
Web unfriendly
protocols
@crichardson
63. NodeJS as an API gateway
Single entry point
Browser
View
Controller
NodeJS
Model
HTML 5 - JavaScript
Product Info
service
REST
Recommendation
Service
AMQP
Review
service
REST
proxy
Native App
View
API
Gateway
REST
Controller
Model
Event
publishing
Optimized Client
specific APIs
Protocol
translation
@crichardson
64. Serving static content with
the Express web framework
var express = require('express')
, http = require('http')
, app = express()
, server = http.createServer(app)
;
From public
sub directory
app.configure(function(){
...
app.use(express.static(__dirname + '/public'));
});
server.listen(8081);
@crichardson
67. Implementing coarsegrained mobile API
var express = require('express'),
...;
app.get('/productdetails/:productId', function (req, res) {
getProductDetails(req.params. productId).then(
function (productDetails) {
res.json(productDetails);
}
});
@crichardson
69. Socket.io server-side
var express = require('express')
, http = require('http')
, amqp = require(‘amqp’)
....;
server.listen(8081);
...
var amqpCon = amqp.createConnection(...);
Handle
socket.io
connection
io.sockets.on('connection', function (socket) {
function amqpMessageHandler(message, headers, deliveryInfo) {
Republish
var m = JSON.parse(message.data.toString());
socket.emit(‘tick’, m);
as socket.io
};
event
amqpCon.queue(“”, {},
function(queue) {
queue.bind(“myExchange”, “”);
queue.subscribe(amqpMessageHandler);
Subscribe to
});
});
AMQP queue
https://github.com/cer/nodejs-clock
@crichardson
70. Socket.io - client side
<html>
<body>
The event is <span data-bind="text: ticker"></span>
<script src="/socket.io/socket.io.js"></script>
<script src="/knockout-2.0.0.js"></script>
<script src="/clock.js"></script>
</body>
</html>
Bind to model
Connect to
socket.io
clock.js
var socket = io.connect(location.hostname);
function ClockModel() {
self.ticker = ko.observable(1);
socket.on('tick', function (data) {
self.ticker(data);
});
};
ko.applyBindings(new ClockModel());
Subscribe
to tick event
Update
model
@crichardson
71. NodeJS is also great for writing
backend micro-services
“Network elements”
Simply ‘route, filter and transform packets’
Have minimal business logic
@crichardson
72. NodeJS-powered home security
FTP Server
Log file
FTP Server
Upload directory
Upload2S3
S3
SQS Queue
UploadQueue
Processor
DynamoDB
@crichardson
73. Summary
JavaScript is a very flawed language
The asynchronous model is often unnecessary; very
constraining; and adds complexity
BUT despite those problems
Today, NodeJS is remarkably useful for building networkfocussed components
@crichardson