Clean Architecture and app modularization are often used together to achieve a better code structure and a faster build time. But how can we use Dagger in an app structured in that way? Can we use subcomponents (with or without Dagger Android) or are component dependencies enough?
In this talk we’ll see how to leverage Dagger to organize the dependencies in a multi-module project with particular attention to testing and decoupling. The examples will be both in a standard layered architecture and in a Clean Architecture where the Dependency Inversion increases the overall structure but can complicate the Dagger code.
Modularizing a project is never easy, a lot of files to move and the dependencies between them is not always what we expect. Then the Dagger configuration used in a single module project often doesn't scale well to a multi module project. Hilt is opinionated about the configuration to use (we don't need to argue anymore about using component dependencies or subcomponents!) and this configuration works perfectly even in a multi module project. In this talk we'll see first an introduction to Hilt and a comparison with Dagger to understand why it's easier to configure. Then we'll see how to leverage it in a multi module project (both in a standard layered architecture and in a Clean Architecture that uses the Dependency Inversion) to improve build speed and code testability. Spoiler alert: using sample apps that include a single feature in the app helps a lot!
Implantação de um Processo de Teste de Software - Randerson Melville minastestingconference
Nessa palestra será apresentada a adoção de um processo de testes de software.Será discutido as dificuldades, desafios e potenciais melhorias com a adoção de um processo, apresentando alguns conceitos, ferramentas e processos de gestão que auxiliam um projeto no início da implantação desse processo. Como forma complementar será apresentado a adoção desse processo em um ambiente ágil de desenvolvimento, bem como apresentação de casos reais de empresas e projetos que implantaram o processo de testes.Serão apresentados os tipos de testes e ferramentas de apoio que podem ser utilziados em ambientes de desenvolvimento mobile, Web e desktop.
This talk was given at "The KISS Method and PageObjects" meetup (https://goo.gl/2DBuxj).
The talk is about KISS (Keep It Simple Stupid) principle applied to PageObjects design with a comparison to other more classic approaches.
The slides contain both Selenium Webdriver and Selenide examples.
src code for the talk: https://github.com/yashaka/talks/tree/master/kiss-pageobjects
Modularizing a project is never easy, a lot of files to move and the dependencies between them is not always what we expect. Then the Dagger configuration used in a single module project often doesn't scale well to a multi module project. Hilt is opinionated about the configuration to use (we don't need to argue anymore about using component dependencies or subcomponents!) and this configuration works perfectly even in a multi module project. In this talk we'll see first an introduction to Hilt and a comparison with Dagger to understand why it's easier to configure. Then we'll see how to leverage it in a multi module project (both in a standard layered architecture and in a Clean Architecture that uses the Dependency Inversion) to improve build speed and code testability. Spoiler alert: using sample apps that include a single feature in the app helps a lot!
Implantação de um Processo de Teste de Software - Randerson Melville minastestingconference
Nessa palestra será apresentada a adoção de um processo de testes de software.Será discutido as dificuldades, desafios e potenciais melhorias com a adoção de um processo, apresentando alguns conceitos, ferramentas e processos de gestão que auxiliam um projeto no início da implantação desse processo. Como forma complementar será apresentado a adoção desse processo em um ambiente ágil de desenvolvimento, bem como apresentação de casos reais de empresas e projetos que implantaram o processo de testes.Serão apresentados os tipos de testes e ferramentas de apoio que podem ser utilziados em ambientes de desenvolvimento mobile, Web e desktop.
This talk was given at "The KISS Method and PageObjects" meetup (https://goo.gl/2DBuxj).
The talk is about KISS (Keep It Simple Stupid) principle applied to PageObjects design with a comparison to other more classic approaches.
The slides contain both Selenium Webdriver and Selenide examples.
src code for the talk: https://github.com/yashaka/talks/tree/master/kiss-pageobjects
How to Split Your System into MicroservicesEberhard Wolff
Splitting a system into microservices is a challenging task. This talk shows how ideas like Bounded Context, migration scenarios and technical constraints can be used to build a microservice architecture. Held at WJAX 2016.
Reactive state management with Jetpack ComponentsGabor Varadi
This talk explains what problems exist in the context of Android application development, how Jetpack components such as SavedStateHandle help handle that, and how we can combine observable values to expose our state, to be observed only when it is needed.
In this iteration of iOS Meetup, The experts from Seven Peaks Software will walk you through on the Swift programming language, Giving you the latest tips and tricks for you to be success on the iOS development
Rupendra opened up the meetup with Concurrency in Swift. Concurrency allows programs to deal with multiple tasks at once. But writing a concurrent program is not as easy as it seems. Dealing with threads and locks can be quite cumbersome, making concurrent programs difficult to write. His Topic will focus on making it straightforward and understandable so that anyone who is an intermediate to advanced Swift developer can apply these concepts to their projects.
Zephyr for JIRA - Test Management
by Zephyr for JIRA
Všechny vaše testy budete spravovat v JIRA.
JIRA addon Zephyr rozšiřuje funkci JIRA o test management.
Czy każdy nadaje się na programistę? Jak rozpocząć drogę przebranżowienia w tym kierunku? I dlaczego bywa, że nie widać postępów w nauce? Na te pytania odpowiadała Patrycja Warmuz, iOS developer w firmie Atos, w trakcie webinaru w ramach programu #MamoPracujwIT
Lo stato dell' arte sulla documentazione dei progetti ICTMatteo Gentile
Ogni progetto informatico è sicuramente incompleto fino a quando non viene corredato da una documentazione esauriente. In un progetto informatico la documentazione è presente in tutte le fasi, dalla raccolta dei requisiti, passando per la documentazione di analisi e tecnica di implementazione, fino ad arrivare alla documentazione per l’utente finale.
Quali documenti è opportuno generare in un progetto ?
La documentazione di progetto va generata all’inizio o alla fine ?
Come fare a tenere sempre aggiornata la documentazione quando i requisiti o le implementazioni cambiano ?
Che standard usare per creare una buona documentazione di un progetto informatico ?
Recentemente c’è stata un'ampia diffusione delle metodologie Agili. E’ vero che non è prevista documentazione ?
Questo evento nasce per rispondere a queste domande e per mostrare attraverso un esempio pratico come introdurre la documentazione in un progetto che usa le metodologie Agili.
Android MVVM architecture using Kotlin, Dagger2, LiveData, MediatorLiveDataWaheed Nazir
Kotlin MVVM Architecture:
A sample app that display list of Google news. The purpose of this project to illustrate the usage of MVVM architecture design pattern that follow the best practices of Object Oriented Design Patterns using the following technology stack.
Architecture Design Pattern
MVVM
Dagger2 (Dependency Injection)
Live Data, MediatorLiveData
Room Database
Retrofit
Unit Testing (Espresso), Mockito (Coming soon)
Repository Pattern
AndroidX
Glide
NetworkBoundResource, NetworkAndDBBoundResource
Google News API
JetPack Libraries
How to Split Your System into MicroservicesEberhard Wolff
Splitting a system into microservices is a challenging task. This talk shows how ideas like Bounded Context, migration scenarios and technical constraints can be used to build a microservice architecture. Held at WJAX 2016.
Reactive state management with Jetpack ComponentsGabor Varadi
This talk explains what problems exist in the context of Android application development, how Jetpack components such as SavedStateHandle help handle that, and how we can combine observable values to expose our state, to be observed only when it is needed.
In this iteration of iOS Meetup, The experts from Seven Peaks Software will walk you through on the Swift programming language, Giving you the latest tips and tricks for you to be success on the iOS development
Rupendra opened up the meetup with Concurrency in Swift. Concurrency allows programs to deal with multiple tasks at once. But writing a concurrent program is not as easy as it seems. Dealing with threads and locks can be quite cumbersome, making concurrent programs difficult to write. His Topic will focus on making it straightforward and understandable so that anyone who is an intermediate to advanced Swift developer can apply these concepts to their projects.
Zephyr for JIRA - Test Management
by Zephyr for JIRA
Všechny vaše testy budete spravovat v JIRA.
JIRA addon Zephyr rozšiřuje funkci JIRA o test management.
Czy każdy nadaje się na programistę? Jak rozpocząć drogę przebranżowienia w tym kierunku? I dlaczego bywa, że nie widać postępów w nauce? Na te pytania odpowiadała Patrycja Warmuz, iOS developer w firmie Atos, w trakcie webinaru w ramach programu #MamoPracujwIT
Lo stato dell' arte sulla documentazione dei progetti ICTMatteo Gentile
Ogni progetto informatico è sicuramente incompleto fino a quando non viene corredato da una documentazione esauriente. In un progetto informatico la documentazione è presente in tutte le fasi, dalla raccolta dei requisiti, passando per la documentazione di analisi e tecnica di implementazione, fino ad arrivare alla documentazione per l’utente finale.
Quali documenti è opportuno generare in un progetto ?
La documentazione di progetto va generata all’inizio o alla fine ?
Come fare a tenere sempre aggiornata la documentazione quando i requisiti o le implementazioni cambiano ?
Che standard usare per creare una buona documentazione di un progetto informatico ?
Recentemente c’è stata un'ampia diffusione delle metodologie Agili. E’ vero che non è prevista documentazione ?
Questo evento nasce per rispondere a queste domande e per mostrare attraverso un esempio pratico come introdurre la documentazione in un progetto che usa le metodologie Agili.
Android MVVM architecture using Kotlin, Dagger2, LiveData, MediatorLiveDataWaheed Nazir
Kotlin MVVM Architecture:
A sample app that display list of Google news. The purpose of this project to illustrate the usage of MVVM architecture design pattern that follow the best practices of Object Oriented Design Patterns using the following technology stack.
Architecture Design Pattern
MVVM
Dagger2 (Dependency Injection)
Live Data, MediatorLiveData
Room Database
Retrofit
Unit Testing (Espresso), Mockito (Coming soon)
Repository Pattern
AndroidX
Glide
NetworkBoundResource, NetworkAndDBBoundResource
Google News API
JetPack Libraries
Dark side of Android apps modularizationDavid Bilík
Slides from mDevCamp 2020 conference
This talk is about modularization of the Android apps. Modularization is a big hot topic in the last couple of years and we've jumped on the train too here at Ackee.
But this talk will not be about rainbows and puppies and about how everything is perfect with modularized app. I would like to talk about darker sides of modularization, the questions that are shady and noone has the right answer for.
Spring boot is a suite, pre-configured, pre-sugared set of frameworks/technologies to reduce boilerplate configuration providing you the shortest way to have a Spring web application up and running with smallest line of code/configuration out-of-the-box.
Comment développer une application mobile en 8 semaines - Meetup PAUG 24-01-2023Nicolas HAAN
À l'automne dernier, nous avons eu la chance de développer une nouvelle app pour un de nos clients en partant de zéro.
L'objectif ? Créer une application minimale à mettre entre les mains de dizaines de beta testeurs, en 8 semaines et avec 2 développeurs. Partant d'une feuille blanche, nous avons pu mettre en œuvre les dernières avancées de la stack Android sans être contraints par l'existant.
Développeurs débutants comme expérimentés, vous repartirez de ce talk avec nos apprentissages clés sur l'architecture ainsi que sur les bibliothèques et astuces pour faciliter la maintenance et la stabilité de l'application. En bonus, nous répondrons à la question : "Une app full-compose, est-ce que c'est cool ?"
original (better quality) on https://docs.google.com/presentation/d/1bnwj8CrFGo5KekONYSeIHySdkoXZiewJxkHcZjXnzkQ/
slides from OpenDaylight Summit Oct 2016 Seattle
Esta charla comprende las lecciones aprendidas convirtiendo la app de Android de Teambox (una app repleta de deuda técnica y con un alto nivel de acoplamiento entre clases), en la versión actual de Redbooth, que intenta cumplir la arquitectura Hexagonal y los principios SOLID. Durante la exposición explicaremos como fuimos desenredando el código paso a paso; como aplicamos por partes los conceptos de la arquitectura hexagonal; como dejamos de lado componentes del framework de Android que dificultaban el mantenimiento de la app; y que errores cometimos, como los solucionamos y como se podrían haber evitado.
Building scalable applications with angular jsAndrew Alpert
AngularJS today is one of the most powerful, user-friendly and popular JS frameworks to work on web applications. Surprisingly, one of the main weaknesses of this framework is poorly structured documentation and the lack of ready-made solutions. In this report, we will try to work out the best approach to the organization of large and very large applications. We will also speak about the tools that will be useful at every stage of the application development and tools and practicesthat will help you to work in the continuous delivery mode.
Many Scala developers nowadays consider using Dependency Injection frameworks an anti-pattern incompatible with modern FP settings. We argue that it's just a consequence of a bad experience with legacy Java runtime reflection-based implementations that lack features important for modern functional programming, such as a first-class support for higher-kinded types. We argue that as a paradigm for structuring purely functional programs, DI with automatic wiring compares favorably against implicits, monad transformers, free monads, algebraic effects, cake pattern et al, enabling scaling and a degree of modularity unachievable by any manual wiring approach. This talk covers DIStage – a transparent, flexible and efficient DI framework for Scala that enables late binding, testability, effect separation and modular resource management at scale, working with, instead of compromising the Scala type system.
Documentation: https://izumi.7mind.io/latest/release/doc/distage/
Design and Implementation patterns have changed in object-oriented languages such as C# with the introduction of new language features, advances in object-oriented design, and the inclusion of functional language aspects. This session will explore the impact this has on design and implementation patterns and how they can be leveraged to build more elegant systems.
Compose is stable, it's time to integrate it into our apps! But it can be harder than expected and there are some questions to answer. Can the same architecture of a View-based app be reused or should we change it? Should the Compose code be aware of the architecture at all? And should the non UI code be changed to start using Compose? What can be replaced with a Composable, only the layouts or also something else?
Probably the best answer to all these questions is “it depends”, in this talk we’ll see some reasons and how to leverage Compose and the other tools to create a good architecture. Compose is more than just a UI framework and it can seem appealing to use it in a big portion of an app, a good architecture can be useful to limit this portion and use it only when necessary.
Using Kotlin coroutines it’s really easy to execute a task in a background thread and update the UI based on the result. Just enter the coroutine world using the launch method and then change thread using withContext. It’s even simpler if the task is an http call (thanks to coroutines support in retrofit) or a database query (thanks to Room). The final code is the same we’d use to execute synchronous code. But coroutines are more than just a tool to switch thread, we can use them to execute tasks in parallel. The code is still really easy to read but sometimes it can be difficult to write: we need to pay attention to many aspects (like nested scopes, exceptions and dispatchers). In this talk we’ll see how to leverage the coroutines library to manage parallelism, from the basic concepts to some advanced example.
Kotlin Delegates in practice - Kotlin community confFabio Collini
The lazy delegate is probably the most famous Kotlin delegate, it’s easy to use and can be really useful. However delegation is a concept that can be used in many other ways in Kotlin. A delegate can be declared at two levels:
* a delegated property allows changing the way the property is managed
* an interface can be implemented delegating the methods to another object
In this talk we’ll see many practical examples to show how to leverage standard delegates and how to create new ones to improve the quality of our code and to avoid duplication.
Kotlin delegates in practice - Kotlin Everywhere StockholmFabio Collini
The lazy delegate is probably the most famous Kotlin delegate, it’s easy to use and can be really useful. However delegation is a concept that can be used in many other ways in Kotlin. A delegate can be declared at two levels:
* a delegated property allows changing the way the property is managed
* an interface can be implemented delegating the methods to another object
In this talk we’ll see many practical examples to show how to leverage standard delegates and how to create new ones to improve the quality of our code and to avoid duplication.
Solid principles in practice the clean architecture - Droidcon ItalyFabio Collini
The Clean Architecture has been formalized by Robert C. Martin in 2012, it's quite new even if it's based on the SOLID principles (presented for the first time in early 2000). The biggest benefit that we get using this architecture is the code testability, indeed it separates the application code from the code connected to external factor (that usually is more difficult to test).
In this talk we'll see a practical example of how to apply the SOLID principle, in particular, the dependency inversion.
SOLID principles in practice: the Clean Architecture - Devfest Emila RomagnaFabio Collini
The Clean Architecture has been formalized by Robert C. Martin in 2012, it's quite new even if it's based on the SOLID principles (presented for the first time in early 2000). The biggest benefit that we get using this architecture is the code testability, indeed it separates the application code from the code connected to external factor (that usually is more difficult to test).
In this talk we'll see a practical example of how to apply the SOLID principle, in particular, the dependency inversion.
SOLID principles in practice: the Clean ArchitectureFabio Collini
The Clean Architecture has been formalized by Robert C. Martin in 2012, it's quite new even if it's based on the SOLID principles (presented for the first time in early 2000). The biggest benefit that we get using this architecture is the code testability, indeed it separates the application code from the code connected to external factor (that usually is more difficult to test).
In this talk we'll see a practical example of how to apply the SOLID principle, in particular, the dependency inversion.
From Java to Kotlin beyond alt+shift+cmd+k - Kotlin Community Conf MilanFabio Collini
Kotlin is a first-class language for Android development since Google I/O 2017. And it’s here to stay!
Thanks to Android Studio it’s really easy to introduce Kotlin in an existing project, the configuration is trivial and then we can convert Java classes to Kotlin using a Alt+Shift+Cmd+K. But the new syntax is the just beginning, using Kotlin we can improve our code making it more readable and simpler to write.
In this talk we’ll see how to use some Kotlin features (for example data classes, collections, coroutines and delegates) to simplify Android development comparing the code with the equivalent “modern” Java code. It’s not fair to compare Kotlin code with plain Java 6 code so the Java examples will use lambdas and some external libraries like RxJava and AutoValue.
Async code on kotlin: rx java or/and coroutines - Kotlin Night TurinFabio Collini
It’s never easy to write async code but luckily there are many libraries to manage asynchronicity without adding too much complexity. In the last years RxJava and the other ReactiveX libraries have been very popular but lately there is a new way to manage async code in Kotlin: the coroutines. In this talk we’ll pros and cons of there two approaches and how to leverage them to simplify asynchronous code on Android.
Do they solve the same problem? Can we use them together? Which one can be used to write functional code? How can we use them effectively in Android development?
Spoiler alert: They are both great!
In this talk we’ll see how to solve common problems using RxJava or Coroutines, starting from basic concepts (for example the Retrofit support and how to cancel a task) to some more advanced (like threading, error management and how to combine multiple tasks).
All example of the talk are available on this repository:
https://github.com/fabioCollini/RxJavaVsCoroutines
From java to kotlin beyond alt+shift+cmd+k - Droidcon italyFabio Collini
Kotlin is a first-class language for Android development since Google I/O 2017. And it’s here to stay!
Thanks to Android Studio it’s really easy to introduce Kotlin in an existing project, the configuration is trivial and then we can convert Java classes to Kotlin using a Alt+Shift+Cmd+K. But the new syntax is the just beginning, using Kotlin we can improve our code making it more readable and simpler to write.
In this talk we’ll see how to use some Kotlin features (for example data classes, collections, coroutines and delegates) to simplify Android development comparing the code with the equivalent “modern” Java code. It’s not fair to compare Kotlin code with plain Java 6 code so the Java examples will use lambdas and some external libraries like RxJava and AutoValue.
From java to kotlin beyond alt+shift+cmd+kFabio Collini
Kotlin is a first-class language for Android development since Google I/O 2017. And it’s here to stay! Thanks to Android Studio it’s really easy to introduce Kotlin in an existing project, the configuration is trivial and then we can convert Java classes to Kotlin using a Alt+Shift+Cmd+K. But the new syntax is the just beginning, using Kotlin we can improve our code making it more readable and simpler to write. In this talk we’ll see how to use some Kotlin features (for example data classes, collections, coroutines and delegates) to simplify Android development comparing the code with the equivalent “modern” Java code. It’s not fair to compare Kotlin code with plain Java 6 code so the Java examples will use lambdas and some external libraries like RxJava and AutoValue.
Testing Android apps based on Dagger and RxJava Droidcon UKFabio Collini
Writing reliable tests is not easy for many reasons, especially when asynchronous code is involved. Some libraries can be used to create a testable architecture (for example Dagger and RxJava) and to simplify testing (Mockito, AssertJ and DaggerMock). In this talk you'll learn how to write JVM and Espresso tests with particular attention on how to replace real objects with mocks and how to test asynchronous RxJava code. In this talk, you will also explore:
how to take advantage of Mockito and other libraries to write good JVM and Espresso tests in both Java and Kotlin
how to use DaggerMock (an open source library available on github to avoid boilerplate code in tests
how to test asynchronous RxJava code using a JVM test
Testing Android apps based on Dagger and RxJavaFabio Collini
In this talk, you will learn:
how to take advantage of Mockito and other libraries to write good JVM and Espresso tests
how to use DaggerMock (an open source library available on github https://github.com/fabioCollini/DaggerMock) to avoid boilerplate code in tests
how to test asynchronous RxJava code using a JVM test
Writing reliable tests is not easy for many reasons, especially when asynchronous code is involved. Some libraries can be used to create a testable architecture (for example Dagger and RxJava) and to simplify testing (Mockito, AssertJ and DaggerMock). In this talk we’ll see how to write JVM and Espresso tests with particular attention on how to replace real objects with mocks and how to test asynchronous RxJava code.
Android Data Binding in action using MVVM pattern - droidconUKFabio Collini
The Data Binding framework was one of Google’s announcements at I/O 2015, it’s a big change in the code organization of an Android app. Some developers are sceptical about this framework but, if used in the “right way”, it’s very powerful and it allows to remove a lot of redundant boilerplate code from activities and fragments.
In this talk we’ll start from the Data Binding basic concepts and then we’ll see how to use it to improve the architecture of a typical Android application applying the Model View ViewModel pattern. Using this pattern you need to write less code to create an app that can be easily tested using JVM and instrumentation tests.
Data Binding in Action using MVVM patternFabio Collini
The Data Binding framework was one of Google’s announcements at I/O 2015, it’s a big change in the code organization of an Android app. Some developers are sceptical about this framework but, if used in the “right way”, it’s very powerful and it allows to remove a lot of redundant boilerplate code from activities and fragments.
In this talk we’ll start from the Data Binding basic concepts and then we’ll see how to use it to improve the architecture of a typical Android application applying the Model View ViewModel pattern. Using this pattern you need to write less code to create an app that can be easily tested using JVM and instrumentation tests.
May Marketo Masterclass, London MUG May 22 2024.pdfAdele Miller
Can't make Adobe Summit in Vegas? No sweat because the EMEA Marketo Engage Champions are coming to London to share their Summit sessions, insights and more!
This is a MUG with a twist you don't want to miss.
AI Genie Review: World’s First Open AI WordPress Website CreatorGoogle
AI Genie Review: World’s First Open AI WordPress Website Creator
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-genie-review
AI Genie Review: Key Features
✅Creates Limitless Real-Time Unique Content, auto-publishing Posts, Pages & Images directly from Chat GPT & Open AI on WordPress in any Niche
✅First & Only Google Bard Approved Software That Publishes 100% Original, SEO Friendly Content using Open AI
✅Publish Automated Posts and Pages using AI Genie directly on Your website
✅50 DFY Websites Included Without Adding Any Images, Content Or Doing Anything Yourself
✅Integrated Chat GPT Bot gives Instant Answers on Your Website to Visitors
✅Just Enter the title, and your Content for Pages and Posts will be ready on your website
✅Automatically insert visually appealing images into posts based on keywords and titles.
✅Choose the temperature of the content and control its randomness.
✅Control the length of the content to be generated.
✅Never Worry About Paying Huge Money Monthly To Top Content Creation Platforms
✅100% Easy-to-Use, Newbie-Friendly Technology
✅30-Days Money-Back Guarantee
See My Other Reviews Article:
(1) TubeTrivia AI Review: https://sumonreview.com/tubetrivia-ai-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
#AIGenieApp #AIGenieBonus #AIGenieBonuses #AIGenieDemo #AIGenieDownload #AIGenieLegit #AIGenieLiveDemo #AIGenieOTO #AIGeniePreview #AIGenieReview #AIGenieReviewandBonus #AIGenieScamorLegit #AIGenieSoftware #AIGenieUpgrades #AIGenieUpsells #HowDoesAlGenie #HowtoBuyAIGenie #HowtoMakeMoneywithAIGenie #MakeMoneyOnline #MakeMoneywithAIGenie
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Do you want Software for your Business? Visit Deuglo
Deuglo has top Software Developers in India. They are experts in software development and help design and create custom Software solutions.
Deuglo follows seven steps methods for delivering their services to their customers. They called it the Software development life cycle process (SDLC).
Requirement — Collecting the Requirements is the first Phase in the SSLC process.
Feasibility Study — after completing the requirement process they move to the design phase.
Design — in this phase, they start designing the software.
Coding — when designing is completed, the developers start coding for the software.
Testing — in this phase when the coding of the software is done the testing team will start testing.
Installation — after completion of testing, the application opens to the live server and launches!
Maintenance — after completing the software development, customers start using the software.
Custom Healthcare Software for Managing Chronic Conditions and Remote Patient...Mind IT Systems
Healthcare providers often struggle with the complexities of chronic conditions and remote patient monitoring, as each patient requires personalized care and ongoing monitoring. Off-the-shelf solutions may not meet these diverse needs, leading to inefficiencies and gaps in care. It’s here, custom healthcare software offers a tailored solution, ensuring improved care and effectiveness.
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
Transform Your Communication with Cloud-Based IVR SolutionsTheSMSPoint
Discover the power of Cloud-Based IVR Solutions to streamline communication processes. Embrace scalability and cost-efficiency while enhancing customer experiences with features like automated call routing and voice recognition. Accessible from anywhere, these solutions integrate seamlessly with existing systems, providing real-time analytics for continuous improvement. Revolutionize your communication strategy today with Cloud-Based IVR Solutions. Learn more at: https://thesmspoint.com/channel/cloud-telephony
Top Features to Include in Your Winzo Clone App for Business Growth (4).pptxrickgrimesss22
Discover the essential features to incorporate in your Winzo clone app to boost business growth, enhance user engagement, and drive revenue. Learn how to create a compelling gaming experience that stands out in the competitive market.
Introducing Crescat - Event Management Software for Venues, Festivals and Eve...Crescat
Crescat is industry-trusted event management software, built by event professionals for event professionals. Founded in 2017, we have three key products tailored for the live event industry.
Crescat Event for concert promoters and event agencies. Crescat Venue for music venues, conference centers, wedding venues, concert halls and more. And Crescat Festival for festivals, conferences and complex events.
With a wide range of popular features such as event scheduling, shift management, volunteer and crew coordination, artist booking and much more, Crescat is designed for customisation and ease-of-use.
Over 125,000 events have been planned in Crescat and with hundreds of customers of all shapes and sizes, from boutique event agencies through to international concert promoters, Crescat is rigged for success. What's more, we highly value feedback from our users and we are constantly improving our software with updates, new features and improvements.
If you plan events, run a venue or produce festivals and you're looking for ways to make your life easier, then we have a solution for you. Try our software for free or schedule a no-obligation demo with one of our product specialists today at crescat.io
Zoom is a comprehensive platform designed to connect individuals and teams efficiently. With its user-friendly interface and powerful features, Zoom has become a go-to solution for virtual communication and collaboration. It offers a range of tools, including virtual meetings, team chat, VoIP phone systems, online whiteboards, and AI companions, to streamline workflows and enhance productivity.
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
E-commerce Application Development Company.pdfHornet Dynamics
Your business can reach new heights with our assistance as we design solutions that are specifically appropriate for your goals and vision. Our eCommerce application solutions can digitally coordinate all retail operations processes to meet the demands of the marketplace while maintaining business continuity.
Software Engineering, Software Consulting, Tech Lead, Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Transaction, Spring MVC, OpenShift Cloud Platform, Kafka, REST, SOAP, LLD & HLD.
7. 1. Speeds up builds
2. Enable on demand delivery
3. Simplify development
4. Reuse modules across apps
5. Experiment with new technologies
6. Scale development teams
7. Enables refactoring
8. Simplifies test automation
Modularization - Why you should care
https://jeroenmols.com/blog/2019/03/06/modularizationwhy/
31. DaggerTip#1
Exception in thread "main" java.lang.IllegalStateException: Component1 must be set
at dagger.internal.Preconditions.checkBuilderRequirement(Preconditions.java:95)
at DaggerComponent2$Builder.build(DaggerComponent2.java:35)
@Component
interface Component1
@Component(dependencies = [Component1::class])
interface Component2
fun main() {
DaggerComponent2.builder()
.build()
}1
32. DaggerTip#1
Exception in thread "main" java.lang.IllegalStateException: Component1 must be set
at dagger.internal.Preconditions.checkBuilderRequirement(Preconditions.java:95)
at DaggerComponent2$Builder.build(DaggerComponent2.java:35)
@Component
interface Component1
@Component(dependencies = [Component1::class])
interface Component2
fun main() {
DaggerComponent2.builder()
.component1(DaggerComponent1.create())
.build()
}1
35. DaggerTip#2
@Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}1
@Component(modules = [Module1::class])
interface Component1 {
val format: DecimalFormat
}2
Module1
Component1
pattern
format
format
36. DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}1
@Component(modules = [Module1::class])
interface Component1 {
val format: DecimalFormat
}2
@Module
class Module2 {
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
interface Component2 {
}4
Module2
Component2
Module1
Component1
pattern
format
format
37. DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
}1
@Component(modules = [Module1::class])
interface Component1 {
}2
@Module
class Module2 {
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
interface Component2 {
val format: DecimalFormat
}4
Module2
Component2
format
Module1
Component1
pattern
format
error: [Dagger/MissingBinding] String cannot be provided without an @Inject constructor or
an @Provides-annotated method.
public abstract interface Component2 {
^
String is injected at
Module2.format(pattern)
DecimalFormat is provided at
Component2.getFormat()
38. DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
}1
@Component(modules = [Module1::class])
interface Component1 {
val pattern: String
}2
@Module
class Module2 {
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
interface Component2 {
val format: DecimalFormat
}4
Module2
Component2
format
Module1
Component1
patternpattern
format
39. DaggerTip#2 @Module
class Module1 {
@Provides
fun pattern() = "#,###.00"
}1
@Component(modules = [Module1::class])
interface Component1 {
val pattern: String
}2
@Module
class Module2 {
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
interface Component2 {
val format: DecimalFormat
}4
Module2
Component2
format
Module1
Component1
patternpattern
format
40. DaggerTip#3
interface Component1 {
val pattern: String
}2
@Module
class Module2 {
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
interface Component2 {
val format: DecimalFormat
}4
41. DaggerTip#3 interface Component1 {
val pattern: String
}2
@Module
class Module2 {
@Provides
fun format(pattern: String) =
DecimalFormat(pattern)
}3
@Component(
modules = [Module2::class],
dependencies = [Component1::class]
)5
interface Component2 {
val format: DecimalFormat
}4
fun main() {
val component1 = object : Component1 {
override val pattern ="#,###.0000"
}3
val component2 = DaggerComponent2.factory().create(component1)
}4
42. @Module
class LibModule {
@Provides
fun provideMyLibObject() = MyLibObject()
}3
@Component(modules = [LibModule::class])
interface LibComponent {
val myLibObject: MyLibObject
}1
Lib
43. @Module
class LibModule {
@Provides
fun provideMyLibObject() = MyLibObject()
}3
@Component(modules = [LibModule::class])
interface LibComponent {
val myLibObject: MyLibObject
}1
Lib
feature2
Lib
feature1
51. interface Feature1Provider {
val feature1Component: Feature1Component
}7
interface LibComponentProvider {
val libComponent: LibComponent
}8
feature1Lib
52. class MyApp : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
interface Feature1Provider {
val feature1Component: Feature1Component
}7
interface LibComponentProvider {
val libComponent: LibComponent
}8
feature1LibApp
53. class MyApp : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
interface Feature1Provider {
val feature1Component: Feature1Component
}7
fun Application.feature1Component() =
(this as Feature1Provider).feature1Component
interface LibComponentProvider {
val libComponent: LibComponent
}8
fun Application.libComponent() =
(this as LibComponentProvider).libComponent
Libfeature1App
54. class MyApp : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
class MyFeature1App : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}3
interface Feature1Provider {
val feature1Component: Feature1Component
}7
fun Application.feature1Component() =
(this as Feature1Provider).feature1Component
interface LibComponentProvider {
val libComponent: LibComponent
}8
fun Application.libComponent() =
(this as LibComponentProvider).libComponent
Libfeature1Feature1AppApp
55. interface ComponentHolder {
val map: MutableMap<KClass<*>, Any>
}1
open class ComponentHolderApp : Application(), ComponentHolder {
override val map = mutableMapOf<KClass<*>, Any>()
}2
inline fun <reified C : Any> ComponentHolder.getOrCreate(factory: () -> C): C =
map.getOrPut(C::class, factory) as C
A “real” implementation is available here:
https://github.com/fabioCollini/CleanWeather/blob/dagger/kotlinUtils/
src/main/java/it/codingjam/cleanweather/kotlinutils/ComponentHolder.kt
56. class MyApp : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
class MyFeature1App : Application(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}3
interface Feature1Provider {
val feature1Component: Feature1Component
}7
fun Application.feature1Component() =
(this as Feature1Provider).feature1Component
interface LibComponentProvider {
val libComponent: LibComponent
}8
fun Application.libComponent() =
(this as LibComponentProvider).libComponent
Libfeature1Feature1AppApp
57. class MyApp : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
class MyFeature1App : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}3
interface Feature1Provider {
val feature1Component: Feature1Component
}7
fun ComponentHolderApp.feature1Component() =
(this as Feature1Provider).feature1Component
interface LibComponentProvider {
val libComponent: LibComponent
}8
fun ComponentHolderApp.libComponent() =
(this as LibComponentProvider).libComponent
Libfeature1Feature1AppApp
58. class MyApp : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}6
class MyFeature1App : ComponentHolderApp(), LibComponentProvider, Feature1Provider {
override val libComponent =
DaggerLibComponent.create()
override val feature1Component =
DaggerFeature1Component.factory().create(libComponent)
}3
interface Feature1Provider {
val feature1Component: Feature1Component
}7
fun ComponentHolderApp.feature1Component() = getOrCreate {
}1
interface LibComponentProvider {
val libComponent: LibComponent
}8
fun ComponentHolderApp.libComponent() = getOrCreate {
}2
Libfeature1Feature1AppApp
59. class MyApp : ComponentHolderApp(), LibComponentProvider, Feature1Provider
class MyFeature1App : ComponentHolderApp(), LibComponentProvider, Feature1Provider
interface Feature1Provider {
val feature1Component: Feature1Component
}7
fun ComponentHolderApp.feature1Component() = getOrCreate {
DaggerFeature1Component.factory()
.create(libComponent())
}1
interface LibComponentProvider {
val libComponent: LibComponent
}8
fun ComponentHolderApp.libComponent() = getOrCreate {
DaggerLibComponent.create()
}2
Feature1App
App Libfeature1
60. class MyApp : ComponentHolderApp()
class MyFeature1App : ComponentHolderApp()
fun ComponentHolderApp.feature1Component() = getOrCreate {
DaggerFeature1Component.factory()
.create(libComponent())
}1
fun ComponentHolderApp.libComponent() = getOrCreate {
DaggerLibComponent.create()
}2
Libfeature1
Feature1App
App
61. @Feature1SingletonScope
@Component(dependencies = [Lib1Component::class, Lib2Component::class])
interface Feature1Component {
//...
}
DaggerTip#5
error: @Feature1SingletonScope Feature1Component depends on more than one scoped component:
@dagger.Component(dependencies = {Lib1Component.class, Lib2Component.class})
^
@Lib1SingletonScope Lib1Component
@Lib2SingletonScope Lib2Component
91. class MainActivityTest {
@get:Rule
val rule = ActivityTestRule(MainActivity::class.java, false, false)
private val useCaseMock = mock<UseCase>()
@Before
fun setUp() {
}2
}4
92. class MainActivityTest {
@get:Rule
val rule = ActivityTestRule(MainActivity::class.java, false, false)
private val useCaseMock = mock<UseCase>()
@Before
fun setUp() {
val app = ApplicationProvider.getApplicationContext<ComponentHolderApp>()
app.map.clear()
app.map[DomainComponent::class] = object : DomainComponent {
override val useCase = useCaseMock
}1
}2
}4
93. class MainActivityTest {
@get:Rule
val rule = ActivityTestRule(MainActivity::class.java, false, false)
private val useCaseMock = mock<UseCase>()
@Before
fun setUp() {
val app = ApplicationProvider.getApplicationContext<ComponentHolderApp>()
app.map.clear()
app.map[DomainComponent::class] = object : DomainComponent {
override val useCase = useCaseMock
}1
}2
@Test
fun launchActivity() {
whenever(useCaseMock.retrieve()) doReturn "ABCDEF"
rule.launchActivity(null)
onView(withId(R.id.text))
.check(matches(withText("ABCDEF")))
}3
}4
94. class MainActivityTest {
@get:Rule
val rule = ActivityTestRule(MainActivity::class.java, false, false)
private val useCaseMock = mock<UseCase>()
@Before
fun setUp() {
val app = ApplicationProvider.getApplicationContext<ComponentHolderApp>()
app.map.clear()
app.map[DomainComponent::class] = object : DomainComponent {
override val useCase = useCaseMock
}1
}2
@Test
fun launchActivity() {
whenever(useCaseMock.retrieve()) doReturn "ABCDEF"
rule.launchActivity(null)
onView(withId(R.id.text))
.check(matches(withText("ABCDEF")))
}3
}4
95. Wrappingup
Component dependencies
Each module exposes:
a Component interface
a method to create the Component
A map in the App can be useful to:
manage singletons
replace real objects with fakes/mocks
96. Links
Demo Project
github.com/fabioCollini/CleanWeather/tree/dagger
Droidcon Italy talk - SOLID principles in practice: the Clean Architecture
youtube.com/watch?v=GlDsfq3xHvo&t=
Implementing Dependency Inversion using Dagger components
medium.com/google-developer-experts/implementing-dependency-inversion-using-dagger-components-d6b0fb3b6b5e
Inversion library
github.com/fabioCollini/Inversion
Yigit Boyar, Florina Muntenescu - Build a Modular Android App Architecture (Google I/O'19)
youtube.com/watch?v=PZBg5DIzNww
Jeroen Mols - Modularization - Why you should care
jeroenmols.com/blog/2019/03/06/modularizationwhy/
Ben Weiss - Dependency injection in a multi module project
medium.com/androiddevelopers/dependency-injection-in-a-multi-module-project-1a09511c14b7
Marcos Holgado - Using Dagger in a multi-module project
proandroiddev.com/using-dagger-in-a-multi-module-project-1e6af8f06ffc