The whole workshop is open source: https://github.com/georgiee/angular-workshop-skipbo
---
Angular Advanced Workshop we gave for KaiserX (Allianz, Dec 2018) to teach advanced topics of Angular in a playful way.
The workshop covered six chapters:
Modules, Components, Routing, RxJS, Testing & Animations.
Each Chapter included a challenge, a markdown document describing step by step what to do while giving challenging tasks to solve. The challenges include git branches to catch up if someone gets lost.
We even covered advanced topics like the event loop (micro/macro tasks), zone.js, onPush, ChangeDetection & switchMap vs mergeMap. I'm so happy that I could share this knowledge and people understood it.
By following my workshop, all 15 developers created a fully working Skip-Bo game within three days. There are animations, advanced unit tests, a implemented AI called Oscar to play for the CPU opponents and so much more!
And the best part
We made everything open source. The whole workshop can be found on github: https://github.com/georgiee/angular-workshop-skipbo
Here the final result:
https://skipbo-angular-workshop.netlify.com
This document discusses RxJava, a library for composing asynchronous and event-based programs in Java. It introduces Observables as the core abstraction in RxJava, which are sequences that emit elements to observers. Operators like filter, map, and flatMap allow modifying and transforming Observables. As an example, it shows how to use RxJava to concurrently search for articles by ID, load each article, fetch like counts, and combine the results into a stream of articles. This is done by chaining flatMap operators to transform the stream of IDs into a stream of articles by asynchronously loading each part in parallel.
Reactive programming with Rx-Java allows building responsive systems that can handle varying workloads and failures. It promotes asynchronous and non-blocking code using observable sequences and operators. Rx-Java was created at Netflix to address issues like network chattiness and callback hell in their API. It transforms callback-based code into declarative pipelines. Key concepts are Observables that emit notifications, Operators that transform Observables, and Subscribers that receive emitted items. Rx-Java gained popularity due to its support for concurrency, error handling, and composability.
Futures allow asynchronous and non-blocking operations in Scala. They represent a value that may be available in the future. Promises allow producing values for futures - a promise can be used to complete a future with a value. Futures can be composed using methods like map, flatMap, and recover to build asynchronous workflows. Callbacks allow non-blocking handling of future results.
This talk was delivered at JavaOne 2013, together with Andrzej Grzesik. We mention the new Date APIs, changes to Collections as well as Streams APIs and of course... Lambdas!
Reactive Fault Tolerant Programming with Hystrix and RxJavaMatt Stine
This document discusses reactive fault tolerant programming using Hystrix and RxJava. It begins with an overview of microservices architecture and how latency can occur between services. It then introduces futures and CompletableFutures as ways to allow asynchronous and parallel processing. RxJava is presented as a reactive programming library that can be used to compose asynchronous and event-based programs. Hystrix is discussed as a library for implementing the circuit breaker pattern to handle failures gracefully in distributed systems. The document provides examples of using RxJava and Hystrix to build fault tolerant reactive microservices.
Streams, Streams Everywhere! An Introduction to RxAndrzej Sitek
Nowadays users expect real time data - tweets, messages, order confirmations etc. - the user's attitude moved to the “push" model and it is high time for us devs to make that step as well.
Reactive Extensions (Rx) is the new hot stuff amongst developers these days. It is a library for composing asynchronous and event-based programs by using observable sequences. Sounds nice?
The only problem is that it can be a bit difficult to approach initially, especially when you come from an imperative world, but once mastered it helps dealing with some common problems in a nicer and cleaner way making your code more readable and easier to maintain.
Multiple implementations of Reactive Extensions helps reusing once learnt concepts between different programming languages. The aim of this talk is to provide a quick introduction to Rx theory and potential usecases. The examples are based on RxJava - the Java VM implementation of Reactive Extensions.
This talk was given at JSSummit 2013. Entitled "Avoiding Callback Hell with Async.js", my talk focused on common pitfalls with asynchronous functions and callbacks in JavaScript, and using the async.js library and its advanced control flows to create cleaner, more manageable code.
The document discusses asynchronous programming with futures and promises in Scala. It covers key topics like:
1) Futures provide a way to reason about parallel operations efficiently in a non-blocking way. Futures represent asynchronous computations with results that can be accessed later.
2) Promises allow completing a future with a value or exception. Callbacks allow accessing future results asynchronously once completed.
3) Functional composition with futures uses methods like map, flatMap, recover to transform and compose futures. For-comprehensions provide a cleaner way to compose futures.
This document discusses RxJava, a library for composing asynchronous and event-based programs in Java. It introduces Observables as the core abstraction in RxJava, which are sequences that emit elements to observers. Operators like filter, map, and flatMap allow modifying and transforming Observables. As an example, it shows how to use RxJava to concurrently search for articles by ID, load each article, fetch like counts, and combine the results into a stream of articles. This is done by chaining flatMap operators to transform the stream of IDs into a stream of articles by asynchronously loading each part in parallel.
Reactive programming with Rx-Java allows building responsive systems that can handle varying workloads and failures. It promotes asynchronous and non-blocking code using observable sequences and operators. Rx-Java was created at Netflix to address issues like network chattiness and callback hell in their API. It transforms callback-based code into declarative pipelines. Key concepts are Observables that emit notifications, Operators that transform Observables, and Subscribers that receive emitted items. Rx-Java gained popularity due to its support for concurrency, error handling, and composability.
Futures allow asynchronous and non-blocking operations in Scala. They represent a value that may be available in the future. Promises allow producing values for futures - a promise can be used to complete a future with a value. Futures can be composed using methods like map, flatMap, and recover to build asynchronous workflows. Callbacks allow non-blocking handling of future results.
This talk was delivered at JavaOne 2013, together with Andrzej Grzesik. We mention the new Date APIs, changes to Collections as well as Streams APIs and of course... Lambdas!
Reactive Fault Tolerant Programming with Hystrix and RxJavaMatt Stine
This document discusses reactive fault tolerant programming using Hystrix and RxJava. It begins with an overview of microservices architecture and how latency can occur between services. It then introduces futures and CompletableFutures as ways to allow asynchronous and parallel processing. RxJava is presented as a reactive programming library that can be used to compose asynchronous and event-based programs. Hystrix is discussed as a library for implementing the circuit breaker pattern to handle failures gracefully in distributed systems. The document provides examples of using RxJava and Hystrix to build fault tolerant reactive microservices.
Streams, Streams Everywhere! An Introduction to RxAndrzej Sitek
Nowadays users expect real time data - tweets, messages, order confirmations etc. - the user's attitude moved to the “push" model and it is high time for us devs to make that step as well.
Reactive Extensions (Rx) is the new hot stuff amongst developers these days. It is a library for composing asynchronous and event-based programs by using observable sequences. Sounds nice?
The only problem is that it can be a bit difficult to approach initially, especially when you come from an imperative world, but once mastered it helps dealing with some common problems in a nicer and cleaner way making your code more readable and easier to maintain.
Multiple implementations of Reactive Extensions helps reusing once learnt concepts between different programming languages. The aim of this talk is to provide a quick introduction to Rx theory and potential usecases. The examples are based on RxJava - the Java VM implementation of Reactive Extensions.
This talk was given at JSSummit 2013. Entitled "Avoiding Callback Hell with Async.js", my talk focused on common pitfalls with asynchronous functions and callbacks in JavaScript, and using the async.js library and its advanced control flows to create cleaner, more manageable code.
The document discusses asynchronous programming with futures and promises in Scala. It covers key topics like:
1) Futures provide a way to reason about parallel operations efficiently in a non-blocking way. Futures represent asynchronous computations with results that can be accessed later.
2) Promises allow completing a future with a value or exception. Callbacks allow accessing future results asynchronously once completed.
3) Functional composition with futures uses methods like map, flatMap, recover to transform and compose futures. For-comprehensions provide a cleaner way to compose futures.
The document discusses reactive programming concepts using RxJava. It introduces observables and observers, where observables push asynchronous events to observers via subscriptions. It explains how to create observables that return asynchronous values, and how operators like map, filter, and flatMap can transform and combine observable streams. Key lessons are that performance depends on operator implementations, debugging subscriptions can be difficult, and IDE support for reactive code is still maturing.
A few slides about asynchrnous programming in Node, from callback hell to control flows using promises, thunks and generators, providing the right amount of abstraction to write great code.
All examples available on https://github.com/troch/node-control-flow.
Building Scalable Stateless Applications with RxJavaRick Warren
RxJava is a lightweight open-source library, originally from Netflix, that makes it easy to compose asynchronous data sources and operations. This presentation is a high-level intro to this library and how it can fit into your application.
This document discusses OHHTTPStubs, a library for stubbing network requests in iOS unit and integration tests. It provides examples of how to use OHHTTPStubs to stub requests and responses using files, JSON objects or code. The document also presents two use cases - refactoring existing network code to make it testable, and stubbing requests for features that depend on not-yet-implemented web services, to allow development and testing ahead of server integration.
Gerenciamento de estado no Angular com NgRxLoiane Groner
The document discusses NgRx and managing state in Angular applications. It introduces NgRx and key concepts like actions, reducers, and effects. It explains how NgRx implements the unidirectional data flow pattern with stores, actions, and reducers. Components dispatch actions and select state from the store as observables. Effects are used to handle asynchronous logic and side effects. Following these patterns with NgRx can help manage complex state and data flow in large Angular applications.
Angular for Java Enterprise Developers: Oracle Code One 2018Loiane Groner
This document provides an agenda and overview for developing Angular applications with Java backend services. It discusses TypeScript patterns that are common with Java, using the Angular CLI, creating REST APIs with Spring Boot, bundling Angular for production, and deploying Angular and Java applications to the cloud using Maven and Docker. It also covers Angular fundamentals like components, templates, dependency injection and modules.
Apache Sling - Distributed Eventing, Discovery, and Jobs (adaptTo 2013)Carsten Ziegeler
The document summarizes a presentation on distributed eventing and jobs using Apache Sling and OSGi technologies. It discusses how OSGi event publishing works, Apache Sling discovery and job handling capabilities, and how events can be used to trigger and distribute jobs across multiple instances in a clustered environment. Key points include how Sling identifies instances, clusters, and topologies, manages job queues and consumers, and distributes jobs based on enabled topics and instance availability.
Angular Optimization Web Performance MeetupDavid Barreto
This document summarizes techniques for optimizing Angular applications, including ahead-of-time compilation, lazy loading, change detection strategies, avoiding memory leaks, and server-side rendering. It provides code examples and compares the performance of different approaches by measuring load times. The main takeaways are that ahead-of-time compilation, lazy loading, and server-side rendering can each significantly improve load performance, and that change detection strategies and unsubscribing from observables are important for memory usage and efficiency.
A practical guide to using RxJava on Android. Tips for improving your app architecture with reactive programming. What are the advantages and disadvantages of using RxJava over standard architecture? And how to connect with other popular Android libraries?
Presented at Droidcon Greece 2016.
Testing React hooks with the new act functionDaniel Irvine
React 16.8 introduced hooks, including a new test function called 'act' which helps better describe what your components do. These slides show how you can use it effectively in your code.
The document discusses Reactive programming concepts using RxJava. It defines key RxJava terms like Observable and Observer. An Observable is the source of events, while an Observer handles incoming events. It also covers how to create Observables from sources like arrays, intervals, and network calls. Operators like filter, map, take, and defaultIfEmpty are demonstrated for transforming Observables.
The Road To Reactive with RxJava JEEConf 2016Frank Lyaruu
This document introduces Reactive Programming with RxJava and how it can be used to create non-blocking applications. It discusses the limitations of blocking code and how RxJava uses Observables and Subscribers to implement reactive and asynchronous operations. It provides examples of converting blocking servlets and HTTP calls to non-blocking using RxJava. While non-blocking code is not always faster, it allows asynchronous operations to utilize threads more efficiently.
The document discusses reactive programming concepts in Java using RxJava. It defines key RxJava terms like Observable, Observer, and Operator. It explains how RxJava uses asynchronous message passing with Observables that push data to Observer subscribers, unlike traditional Java APIs that use synchronous pulling of data. It provides examples of creating Observables and applying operators like map, filter, and flatMap. It also covers multi-threading in RxJava using schedulers, backpressure, and other advanced topics.
An exploration into RxJava on Android for the experienced, yet uninitiated software engineer. This presentation explores Declarative vs Imperative programming paradigms and expands the discussion into Functional Reactive Programming. It explains the benefits of the observer contract, high-order functions, and schedulers available in RxJava. It also explains the purpose of the Android integration libraries: RxAndroid, RxLifecycle, and RxBindings.
A presentation given to Overstock.com IT at annual conference. Twitter @TECHknO 2015. Goal of the presentation is to provide a good introduction to the reactive programming model with RxJava.
Full-Stack Reativo com Spring WebFlux + Angular - FiqueEmCasaConfLoiane Groner
The document discusses building a full-stack reactive application with Spring WebFlux for the backend and Angular for the frontend. It covers reactive programming concepts, implementing a reactive backend with Spring WebFlux, building a reactive frontend with Angular, and managing state with NgRx and RxJS. Code samples are provided for a reactive Mongo repository, controller, and integrating Angular Http calls with Spring endpoints.
The document introduces RxJava and how it can be used in Android applications, describing key concepts like Observables, Observers, Operators, and Subjects that allow asynchronous and event-based code to be written in a reactive style. It provides examples of how RxJava can be used to fetch toilet data from an API and handle the asynchronous response more declaratively compared to using callbacks. The document also discusses how subjects can act as both observables that emit events and observers that receive events, making them useful for building event buses between activities.
Real world functional reactive programmingEric Polerecky
FRP is about programming with asynchronous data streams declaratively. Reactive programming treats everything as an asynchronous data stream. FRP uses concepts from functional programming like immutable data and first class functions. The key abstraction in FRP is IObservable which represents a stream of events or values over time. FRP is useful for handling events, stateful applications, and incoming data streams from sources like the file system, sensors, or HTTP requests.
RxJava is a library for composing asynchronous and event-based programs using observable sequences for the Java VM. It provides APIs for asynchronous programming with observable streams. Reactive Extensions (Rx) is a library that supports reactive programming with observable streams in many languages. Netflix adopted RxJava to address issues with its legacy API and improve performance of its services. RxJava uses Observables to build responsive and resilient applications in a reactive style.
Adding a modern twist to legacy web applicationsJeff Durta
Avoid misery of working with legacy code
We will see how you can add independent and isolated components to existing pages; pages that may be difficult to change
React and Flux allow you to make self-contained additions that handle their own data access/persistence
Complex Made Simple: Sleep Better with TorqueBoxbobmcwhirter
The document discusses using TorqueBox, a Ruby application server based on JRuby and JBoss AS7, to deploy a Rails application in production. It compares various deployment options from rolling your own infrastructure to using a platform as a service like Heroku. TorqueBox provides a middle ground where it handles services like caching, background jobs, scheduling, and clustering but still allows customization. The document walks through migrating an existing Rails app's Delayed::Job and caching implementations to use TorqueBox equivalents to simplify the deployment.
The document discusses reactive programming concepts using RxJava. It introduces observables and observers, where observables push asynchronous events to observers via subscriptions. It explains how to create observables that return asynchronous values, and how operators like map, filter, and flatMap can transform and combine observable streams. Key lessons are that performance depends on operator implementations, debugging subscriptions can be difficult, and IDE support for reactive code is still maturing.
A few slides about asynchrnous programming in Node, from callback hell to control flows using promises, thunks and generators, providing the right amount of abstraction to write great code.
All examples available on https://github.com/troch/node-control-flow.
Building Scalable Stateless Applications with RxJavaRick Warren
RxJava is a lightweight open-source library, originally from Netflix, that makes it easy to compose asynchronous data sources and operations. This presentation is a high-level intro to this library and how it can fit into your application.
This document discusses OHHTTPStubs, a library for stubbing network requests in iOS unit and integration tests. It provides examples of how to use OHHTTPStubs to stub requests and responses using files, JSON objects or code. The document also presents two use cases - refactoring existing network code to make it testable, and stubbing requests for features that depend on not-yet-implemented web services, to allow development and testing ahead of server integration.
Gerenciamento de estado no Angular com NgRxLoiane Groner
The document discusses NgRx and managing state in Angular applications. It introduces NgRx and key concepts like actions, reducers, and effects. It explains how NgRx implements the unidirectional data flow pattern with stores, actions, and reducers. Components dispatch actions and select state from the store as observables. Effects are used to handle asynchronous logic and side effects. Following these patterns with NgRx can help manage complex state and data flow in large Angular applications.
Angular for Java Enterprise Developers: Oracle Code One 2018Loiane Groner
This document provides an agenda and overview for developing Angular applications with Java backend services. It discusses TypeScript patterns that are common with Java, using the Angular CLI, creating REST APIs with Spring Boot, bundling Angular for production, and deploying Angular and Java applications to the cloud using Maven and Docker. It also covers Angular fundamentals like components, templates, dependency injection and modules.
Apache Sling - Distributed Eventing, Discovery, and Jobs (adaptTo 2013)Carsten Ziegeler
The document summarizes a presentation on distributed eventing and jobs using Apache Sling and OSGi technologies. It discusses how OSGi event publishing works, Apache Sling discovery and job handling capabilities, and how events can be used to trigger and distribute jobs across multiple instances in a clustered environment. Key points include how Sling identifies instances, clusters, and topologies, manages job queues and consumers, and distributes jobs based on enabled topics and instance availability.
Angular Optimization Web Performance MeetupDavid Barreto
This document summarizes techniques for optimizing Angular applications, including ahead-of-time compilation, lazy loading, change detection strategies, avoiding memory leaks, and server-side rendering. It provides code examples and compares the performance of different approaches by measuring load times. The main takeaways are that ahead-of-time compilation, lazy loading, and server-side rendering can each significantly improve load performance, and that change detection strategies and unsubscribing from observables are important for memory usage and efficiency.
A practical guide to using RxJava on Android. Tips for improving your app architecture with reactive programming. What are the advantages and disadvantages of using RxJava over standard architecture? And how to connect with other popular Android libraries?
Presented at Droidcon Greece 2016.
Testing React hooks with the new act functionDaniel Irvine
React 16.8 introduced hooks, including a new test function called 'act' which helps better describe what your components do. These slides show how you can use it effectively in your code.
The document discusses Reactive programming concepts using RxJava. It defines key RxJava terms like Observable and Observer. An Observable is the source of events, while an Observer handles incoming events. It also covers how to create Observables from sources like arrays, intervals, and network calls. Operators like filter, map, take, and defaultIfEmpty are demonstrated for transforming Observables.
The Road To Reactive with RxJava JEEConf 2016Frank Lyaruu
This document introduces Reactive Programming with RxJava and how it can be used to create non-blocking applications. It discusses the limitations of blocking code and how RxJava uses Observables and Subscribers to implement reactive and asynchronous operations. It provides examples of converting blocking servlets and HTTP calls to non-blocking using RxJava. While non-blocking code is not always faster, it allows asynchronous operations to utilize threads more efficiently.
The document discusses reactive programming concepts in Java using RxJava. It defines key RxJava terms like Observable, Observer, and Operator. It explains how RxJava uses asynchronous message passing with Observables that push data to Observer subscribers, unlike traditional Java APIs that use synchronous pulling of data. It provides examples of creating Observables and applying operators like map, filter, and flatMap. It also covers multi-threading in RxJava using schedulers, backpressure, and other advanced topics.
An exploration into RxJava on Android for the experienced, yet uninitiated software engineer. This presentation explores Declarative vs Imperative programming paradigms and expands the discussion into Functional Reactive Programming. It explains the benefits of the observer contract, high-order functions, and schedulers available in RxJava. It also explains the purpose of the Android integration libraries: RxAndroid, RxLifecycle, and RxBindings.
A presentation given to Overstock.com IT at annual conference. Twitter @TECHknO 2015. Goal of the presentation is to provide a good introduction to the reactive programming model with RxJava.
Full-Stack Reativo com Spring WebFlux + Angular - FiqueEmCasaConfLoiane Groner
The document discusses building a full-stack reactive application with Spring WebFlux for the backend and Angular for the frontend. It covers reactive programming concepts, implementing a reactive backend with Spring WebFlux, building a reactive frontend with Angular, and managing state with NgRx and RxJS. Code samples are provided for a reactive Mongo repository, controller, and integrating Angular Http calls with Spring endpoints.
The document introduces RxJava and how it can be used in Android applications, describing key concepts like Observables, Observers, Operators, and Subjects that allow asynchronous and event-based code to be written in a reactive style. It provides examples of how RxJava can be used to fetch toilet data from an API and handle the asynchronous response more declaratively compared to using callbacks. The document also discusses how subjects can act as both observables that emit events and observers that receive events, making them useful for building event buses between activities.
Real world functional reactive programmingEric Polerecky
FRP is about programming with asynchronous data streams declaratively. Reactive programming treats everything as an asynchronous data stream. FRP uses concepts from functional programming like immutable data and first class functions. The key abstraction in FRP is IObservable which represents a stream of events or values over time. FRP is useful for handling events, stateful applications, and incoming data streams from sources like the file system, sensors, or HTTP requests.
RxJava is a library for composing asynchronous and event-based programs using observable sequences for the Java VM. It provides APIs for asynchronous programming with observable streams. Reactive Extensions (Rx) is a library that supports reactive programming with observable streams in many languages. Netflix adopted RxJava to address issues with its legacy API and improve performance of its services. RxJava uses Observables to build responsive and resilient applications in a reactive style.
Adding a modern twist to legacy web applicationsJeff Durta
Avoid misery of working with legacy code
We will see how you can add independent and isolated components to existing pages; pages that may be difficult to change
React and Flux allow you to make self-contained additions that handle their own data access/persistence
Complex Made Simple: Sleep Better with TorqueBoxbobmcwhirter
The document discusses using TorqueBox, a Ruby application server based on JRuby and JBoss AS7, to deploy a Rails application in production. It compares various deployment options from rolling your own infrastructure to using a platform as a service like Heroku. TorqueBox provides a middle ground where it handles services like caching, background jobs, scheduling, and clustering but still allows customization. The document walks through migrating an existing Rails app's Delayed::Job and caching implementations to use TorqueBox equivalents to simplify the deployment.
Presentation to the MIT IAP HTML5 Game Development Class on Debugging and Optimizing Javascript, Local storage, Offline Storage and Server side Javascript with Node.js
A case study of the changes and transition from ZF1 to ZF2 in the Zend Server UI project in Webinar form: http://www.zend.com/en/webinar/Framework/70170000000bwxn-ZSVR6UI-ZF2-20130129.flv
Java 9 is expected to include several new features and changes, including:
- New collection factory methods like Set.of() and Map.of() that provide immutable collections.
- Enhancements to the Stream API such as takeWhile() and dropWhile().
- Syntax changes like allowing effectively final variables in try-with-resources and @SafeVarargs for private methods.
- The addition of JShell to provide a Java REPL.
- Garbage First (G1) garbage collector becoming the default collector.
- Various performance and logging improvements.
Create ReactJS Component & publish as npm packageAndrii Lundiak
How to prepare your (provider) ReactJS component and let your friends (consumer) to use it.
What issues you may face with Babel, Webpack, Eslint, Node, npm.
When to use “npm link” approach and “npm publish” approach.
What else to read and to try.
How do we go from your Java code to the CPU assembly that actually runs it? Using high level constructs has made us forget what happens behind the scenes, which is however key to write efficient code.
Starting from a few lines of Java, we explore the different layers that constribute to running your code: JRE, byte code, structure of the OpenJDK virtual machine, HotSpot, intrinsic methds, benchmarking.
An introductory presentation to these low-level concerns, based on the practical use case of optimizing 6 lines of code, so that hopefully you to want to explore further!
Presentation given at the Toulouse (FR) Java User Group.
Video (in french) at https://www.youtube.com/watch?v=rB0ElXf05nU
Slideshow with animations at https://docs.google.com/presentation/d/1eIcROfLpdTU2_Z_IKiMG-AwqZGZgbN1Bs2E0nGShpbk/pub?start=true&loop=false&delayms=60000
The sprint report summarizes work done in Sprint 17 of the ManageIQ project, including developing REST API actions for managing VMs, converting parts of the UI to use jQuery and AngularJS, integrating additional cloud providers, and performing upgrades to prepare for Rails 4. Testing and architecture work also continued around areas like Dockerization, caching, and the provider layer. Future iterations will focus on additional providers, IPv6 support, and fleecing capabilities.
Peter Lawrey is the CEO of Chronicle Software. He has 7 years experience working as a Java developer for investment banks and trading firms. Chronicle Software helps companies migrate to high performance Java code and was involved in one of the first large Java 8 projects in production in December 2014. The company offers workshops, training, consulting and custom development services. The talk will cover reading and writing lambdas, capturing vs non-capturing lambdas, transforming imperative code to streams, mixing imperative and functional code, and taking Q&A.
Fundamental Node.js (Workshop bersama Front-end Developer GITS Indonesia, War...GITS Indonesia
Salah satu front-end developer GITS Indonesia, Warsono, mengisi workshop di universitas, mengenai Vue.js.
Ikuti kami di kanal berikut, agar tidak ketinggalan acara seru:
Instagram: @gitsindonesia
LinkedIn: GITS Indonesia
Website: gits.id
This document discusses test automation for NoSQL databases. It introduces NoSQL Unit, an open source framework for testing persistence layers of NoSQL databases. NoSQL Unit allows loading test data, connecting to databases, and comparing expected and actual data. It supports databases like MongoDB, Cassandra, Elasticsearch and Redis. The document also discusses using Travis CI for continuous integration of NoSQL database tests. Travis CI is a free service that runs builds and tests of GitHub projects. It can be configured using a .travis.yml file to install databases and run tests as part of the build.
Intro To JavaScript Unit Testing - Ran MizrahiRan Mizrahi
The document introduces JavaScript testing and test-driven development (TDD). It discusses why software projects fail, challenges of testing JavaScript code, and how to use the Mocha and ChaiJS frameworks for TDD and behavior-driven development (BDD). It provides an example of writing unit tests for a user service function using TDD principles, implementing the code to pass the tests, and running the tests with Mocha. Benefits of testing code include short feedback cycles, high test coverage, documentation of specifications, and less time spent debugging.
Slides from my talk "Node.js Patterns for Discerning Developers" given at Pittsburgh TechFest 2013. This talk detailed common design pattern for Node.js, as well as common anti-patterns to avoid.
Object-Oriented Programming has well established design principles, such as SOLID. For many developers architecture and functional programming are at odds with each other: they don’t know how their existing tricks of the trade convert into functional design. This problem becomes worse as hybrid languages such as Scala, Java 8 and Ruby become common. I will talk about how functional programming helps you implement the SOLID principles, and how a functional mindset can actually help you achieve the holy grail of OO, encapsulation.
Adding a modern twist to legacy web applicationsJeff Durta
Avoid misery of working with legacy code
We will see how you can add independent and isolated components to existing pages; pages that may be difficult to change
React and Flux allow you to make self-contained additions that handle their own data access/persistence
Performance measurement methodology — Maksym Pugach | Elixir Evening Club 3Elixir Club
Доповідь Максима Пугача, Team Lead/Software Engineer at LITSLINK, на Elixir Evening Club 3, Kyiv, 13.12.2018
Наступна конференція - http://www.elixirkyiv.club/
A boss of mine once told me "Just see, my poorly written Vert.x app outperforms my poorly written Elixir app". Now it is time to take up the gauntlet.
Cлідкуйте за нами у соцмережах @ElixirClubUA та #ElixirClubUA
Анонси та матеріали конференцій - https://www.fb.me/ElixirClubUA
Новини - https://twitter.com/ElixirClubUA
Фото та невимушена атмосфера - https://www.instagram.com/ElixirClubUA
*Канал організаторів мітапа - https://t.me/incredevly
How to make a high-quality Node.js app, Nikita GalkinSigma Software
This document discusses how to build high quality Node.js applications. It covers attributes of quality like understandability, modifiability, portability, reliability, efficiency, usability, and testability. For each attribute, it provides examples of what could go wrong and best practices to achieve that attribute, such as using dependency injection for modifiability, environment variables for portability, and graceful shutdown for reliability. It also discusses Node.js programming paradigms like callbacks, promises, and async/await and recommends best practices for testing Node.js applications.
Functional Programming with JavaScriptMark Shelton
Introductory talk to using Functional Programming in Vanilla JavaScript. Includes 5 practical examples with worked solutions in ES6+, ES5, and with currying. See Github repo for more: https://github.com/fp-uwa/getting-started-javascript
Summary:
Intro to JavaScript
Developments in JavaScript
Array Functions
Currying & Closures
Useful Resources & Next Steps
Functional Programming Meetup at The University of Western Australia.
Speaker: Mark Shelton. Date: 10 November 2017.
Mark Shelton: https://markshelton.me | @marksheltonwa
Standardizing JavaScript Decorators in TC39 (Full Stack Fest 2019)Igalia
By Daniel Ehrenberg.
JavaScript decorators were created in 2014 as a collaboration among the JavaScript ecosystem, and you've been able to use them in TypeScript and Babel. But they didn't make it into the JavaScript standard yet: not ES6, or any of the later versions, so far. We're working on standardizing decorators in TC39, the JavaScript standards committee, but some changes are required from the initial version.
In this talk, Daniel will explain what TC39 is and how we work. We'll look at some newer language feature proposals, such as Temporal and immutable records and tuples, and follow how decorators have been proceeding through the TC39 process, including why and how they're changing. TC39 could use your help in moving JavaScript forward.
(c) Full Stack Fest 2019
Sitges, Barcelona
September 4—6, 2019
https://2019.fullstackfest.com/
Similar to Angular Advanced Workshop (+ Challenges) (20)
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
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
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.
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:
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
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.
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
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.
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.
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.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
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.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
26. Your tasks
· Create our GameService
· Provide expected interface (TDD)
· Inject the GameService
· Break the Injection and fix it
· Answer a quick question
35. View Encapsulation
· BEM anyone?
· Scoped Styles in ShadowDOM standard
!
· Angular Native & Emulated
· Native 0, ShadowDom 1
· (Example)
36. Smart & Dumb
· presentational not dumb!
· presentational: rely on inputs only, no
huge logic inside
· smart: state, sometimes business logic,
fetch data
· (Example)
37. OnPush
· Important Concept but CD makes it
difficult
· Rely only on inputs (presentational )
· Performance: Website Example
· Still updating: UI events, Async Pipes
· Live Example
46. Router Outlet
· Anchor point for mounted components
· Exposes reference #myTemplateVar="outlet"
47. Lazy Load
So easy to do.
loadChildren: './lazy-load/lazy-load.module#LazyLoadModule'
· Works by convention
· Usually you use a empty route inside.
· (Example)
48. Manual Loading a Module
· lazyModules key in angular.json
· creates a chunk
· load by convention url
· Use it with NgModuleFactoryLoader
· (Example)
49. Guards
· Protect your pages
· Interfaces: CanActivate, CanDeactivate, ..
· ng g guard my-protector
· (Example)
50. Resolver
· Ensure a component gets its data
· Access via route.snapshot.data
· Example
64. · Introduction
· Debugging
· About Dollar Signs
· Cold vs Hot Observables
· Make Cold Observables Hot
· RxJS in the wild
· Testing
65. Introduction
· Extended Observer Pattern (Gang of Four)
· Subject and Observers
· Event System is an Observer Pattern
Chapter 04 — RxJS: Introduction
70. Tag =
!
Key; notification = subscribe<br>
Tag =
!
Key; notification = next; value = {key: "a"…}
Tag =
!
Key; notification = next; value = {key: "b"…}
!
Key notification = unsubscribe<br>
Chapter 04 — RxJS: Debugging
71. Dollar Sign
const click$ = Observable.fromEvent(button, 'click');
· pluralization, called Finnish notation
· peopl€, mic€, oxe₦
72. Cold vs Hot Observables
A cold observable creates its producer on
each subscription, a hot observables closes
over an already existing instance.
— Ben Lesh
Chapter 04 — RxJS: Cold vs Hot
73. // COLD (unicast)
var cold = new Observable((observer) => {
var producer = new Producer();
producer.listen(() => {
observer.next()
});
});
// HOT (multicast)
var producer = new Producer();
var hot = new Observable((observer) => {
producer.listen(() => {
observer.next()
});
});
Chapter 04 — RxJS: Cold vs Hot
74. Make Cold Observable Hot
· Cold: Create a producer (like a
websocket) for each subscriber
· Make Hot: Create only one producer,
then send same data to all susbcribers
Chapter 04 — RxJS: Make Cold Observable Hot
75. const myInterval = interval(500).pipe(
tap(value => console.log('interval produced a value'))
);
myInterval.subscribe(value => {
console.log('received a value', value)
});
myInterval.subscribe(value => {
console.log('received a value', value)
});
/**
interval produced a value
received a value 0
interval produced a value
received a value 0
*/
Chapter 04 — RxJS: Make Cold Observable Hot
76. const myInterval = interval(500).pipe(
tap(value => console.log('interval produced a value'))
);
const subject = new Subject();
// 1. let this subject subscribe to the cold observable
myInterval.subscribe(subject);
// 2. now let future observables subscribe to the subject instead of the interval
subject.subscribe(value => console.log('received a value', value));
subject.subscribe(value => console.log('received a value', value));
subject.subscribe(value => console.log('received a value', value));
/**
interval produced a value
received a value 0
received a value 0
received a value 0
*/
Chapter 04 — RxJS: Make Cold Observable Hot
77. RxJS in the wild
· asObservable vs. Subject
· BehaviourSubject
· destroy & takeUntil
· toArray
78. private _changed: Subject<any> = new Subject();
get changed(): Observable<any> {
return this._changed.asObservable();
}
· A subject is both an observer and
observable
· Prevent the observer part (next)
· changed.next('new value')
Chapter 04 — RxJS: RxJS in the wild
79. · Hot Observables can produce values
without someone listening.
· Page mounted vs Data already
delivered
!
· BehaviorSubject is the solution
Chapter 04 — RxJS: RxJS in the wild
80. const subjectA = new Subject();
const subjectB = new BehaviorSubject(null);
subjectA.next('your loaded data');
subjectB.next('your loaded data');
subjectA.subscribe(value => console.log('value from subjectA:', value));
subjectB.subscribe(value => console.log('value from subjectB:', value));
// value from subjectB: your loaded data
Chapter 04 — RxJS: RxJS in the wild
81. · addEvenListener -> removeEventListener
· subscribe -> unsubscribe
· This is bad
class YourComponent {
initService() {
this.yourService.subscribe(data => {
// do something nice
})
}
}
Chapter 04 — RxJS: RxJS in the wild
83. private _destroyed: Subject<any> = new Subject();
initService() {
this.yourService
.pipe(
takeUntil(this._destroyed)
).subscribe(data => {
// do something nice
})
}
ngOnDestroy() {
this._destroyed.next();
}
Chapter 04 — RxJS: RxJS in the wild
84. RxJS Testing
· RxJS is basically synchronous
· Test for effects, don't test the stream
itself.
· Forward time with tick & fakeAsync
· Never use Marble Testing to test streams
· (Example rxjs/testing)
97. What are Macro Tasks?
Queued up but allow the browser engine
to render between each task.
· scripts
· setTimeout / setInterval
· event listener callbacks
document.appendChild(el);
el.style.display = 'none';
Chapter 05 — Testing: Micro & Macro Tasks
98. What are Microtasks?
They are queued up and executed at the
end of a task. No browser action in
between.
· MutationObserver callback (DOM
changes)
· Promises (even settled ones)
Chapter 05 — Testing: Micro & Macro Tasks
99. // endless (macro) tasks queue - is useless but okay
function cb() {
console.log('cb');
setTimeout(cb, 0)
}
cb();
//
⚠ ⚠ ⚠
This will hang your browser
// — save everything then try
"
function cb() {
console.log('cb');
Promise.resolve().then(cb);
}
cb();
Chapter 05 — Testing: Micro & Macro Tasks
109. Your tasks
· Stock Bug (Investigate)
· Stock Bug — Part 1, 2, 3
· Test RxJS w/ Oscar
"
— CPUs
· Test RxJS w/ Oscar
"
— Humans
· Can Oscar play multiple cards ?