Functional Patterns with Java8 @Bucharest Java User Group
Download as pptx, pdf1 like42,862 views
The document features a live coding marathon led by Victor Rentea focused on functional programming patterns using Java 8. It outlines various programming techniques, best practices, and design patterns while promoting the use of clean code. The session encourages interactions and offers resources for further learning through GitHub repositories and a post-event discussion.
1 of 22
Downloaded 29 times
Ad
Recommended
Clean Pragmatic Architecture - Avoiding a Monolith
Clean Pragmatic Architecture - Avoiding a MonolithVictor Rentea This document outlines key principles for creating clean and pragmatic architecture in enterprise Java applications, emphasizing concepts such as single responsibility, avoiding duplication, and maintaining simplicity. It discusses techniques like dependency inversion, favoring composition over inheritance, and the benefits of pair programming. Overall, the material serves as a guide for best practices in software development to enhance maintainability and developer comfort.
Don't Be Mocked by your Mocks - Best Practices using Mocks
Don't Be Mocked by your Mocks - Best Practices using MocksVictor Rentea The document is a training resource by Victor Rentea, focused on unit testing, design patterns, and mocking techniques for software development. It emphasizes the importance of creating pure functions, managing dependencies, and the appropriate use of mocks and stubs in testing. Additionally, it provides insights on testing strategies, handling complex code, and ensuring robustness in test design.
Clean Lambdas & Streams in Java8
Clean Lambdas & Streams in Java8Victor Rentea The document outlines a workshop conducted by Victor Rentea on clean lambdas and streams in Java 8, scheduled for March 10, 2017. It includes hands-on experiences focusing on searching, transforming, and cleaning streams, along with a discussion on best practices. The workshop aims to enhance Java developers' understanding of lambda expressions and functional programming concepts in Java 8.
The Art of Clean code
The Art of Clean codeVictor Rentea The document outlines principles of clean code, emphasizing readability and maintainability in software development. It covers topics such as naming conventions, the Single Responsibility Principle, class structure, and best practices for commenting and formatting code. The presentation advocates for continuous refactoring and collaboration to ensure code quality over time.
Integration testing with spring @snow one
Integration testing with spring @snow oneVictor Rentea This document provides an overview of integration testing strategies and techniques. It discusses the differences between unit tests and integration tests, including that integration tests involve multiple layers and dependencies like databases, files, and web services, making them slower and more fragile. It also covers best practices for integration tests such as using an in-memory database, WireMock for stubbing external services, transaction management, and strategies for cleaning up after tests.
The Art of Unit Testing - Towards a Testable Design
The Art of Unit Testing - Towards a Testable DesignVictor Rentea The document discusses principles and practices of unit testing, emphasizing the importance of writing effective tests to ensure maintainable and functional code. It outlines strategies, such as Test-Driven Development (TDD) and the necessity of clear test design to catch bugs efficiently. Additionally, it explores testing legacy code challenges and provides examples of clean coding practices for improved test reliability.
Clean Code - The Next Chapter
Clean Code - The Next ChapterVictor Rentea The document discusses clean code principles such as naming conventions, small functions, avoiding nulls and side effects, and using classes as containers for logic. It also emphasizes writing code for readability through techniques like extracting methods, renaming variables for clarity, and using comments to explain intentions rather than restate code. The presenter advocates for clean code as a way to improve code quality and maintainability over time.
The tests are trying to tell you [email protected]
The tests are trying to tell you [email protected]Victor Rentea The document discusses principles of effective unit testing and design feedback, emphasizing the importance of design hints derived from testing practices. It highlights the pitfalls of over-mocking, advocates for simpler data structures, and promotes the use of precise signatures to reduce complexity. The content also suggests that unit testing enhances design quality by enforcing a clearer architecture and facilitating easier refactoring.
Clean Code
Clean CodeVictor Rentea This document by Victor Rentea focuses on the principles of clean code in enterprise Java, emphasizing the importance of readability, maintainability, and proper naming conventions. It covers various aspects such as the structure of functions, classes, and comments, advocating for small, self-explanatory methods and clear class designs to enhance team collaboration and code quality. The document also discusses advanced topics such as side effects, command/query separation, and the distinctions between objects and data structures to promote effective software development practices.
Clean pragmatic architecture @ devflix
Clean pragmatic architecture @ devflixVictor Rentea Victor Rentea introduces himself as a Java Champion, trainer, and speaker who focuses on topics like Hibernate, Spring, Java 8/FP, architecture, clean code, unit testing, reactive programming, and Java performance. He advocates building a deep, rich domain model with value objects and entities that encapsulate logic and enforce invariants. The document provides guidance on applying principles like separating concerns with layers, dependency inversion, and avoiding anemic domain models in order to build flexible, testable systems that are decoupled from frameworks and external dependencies.
clean code book summary - uncle bob - English version
clean code book summary - uncle bob - English versionsaber tabatabaee The document provides guidance on writing clean code based on the book "Clean Code" by Robert Cecil Martin. Some of the key points discussed include:
- Functions should do one thing and do it well, with a single level of abstraction and no side effects. They should fit on a screen.
- Names should be meaningful, avoid abbreviations, and use consistent vocabulary. Class names should be nouns and method names should be verbs.
- Code formatting is important for readability. Classes should not exceed 200 lines, functions a single screen. Variables should be declared near use.
- Comments should only explain why unusual decisions were made, not what the code does. Avoid commented out code or redundant comments
Extreme Professionalism - Software Craftsmanship
Extreme Professionalism - Software CraftsmanshipVictor Rentea This document discusses the concept of extreme professionalism in software craftsmanship, emphasizing the importance of understanding technologies, collective code ownership, and continuous learning. It contrasts the roles of developers and database administrators, highlights the challenges of overspecialization and overengineering, and stresses the need for better collaboration and practices in development. The author, Victor Rentea, outlines a 'software craftsperson's oath' that encourages high-quality coding, learning, and teamwork.
Software Craftsmanship @Code Camp Festival 2022.pdf
Software Craftsmanship @Code Camp Festival 2022.pdfVictor Rentea The document discusses the evolution of software craftsmanship and its importance in developing a technical culture among developers. It emphasizes the need for collective code ownership, continuous learning, and adapting to changing technologies to enhance developers' adaptability and effectiveness. Key concepts include overcoming overspecialization, promoting agile practices, and fostering environments that encourage collaboration and knowledge sharing.
Vertical Slicing Architectures
Vertical Slicing ArchitecturesVictor Rentea The document outlines a comprehensive training session by Victor Rentea, focusing on software architecture techniques including concentric architectures, vertical slicing, and microservices. It covers principles such as dependency inversion, testing strategies, and the importance of clear module boundaries, emphasizing best practices in designing scalable and maintainable software systems. Additionally, it addresses common pitfalls like overengineering and nano-services, while providing resources and examples for further understanding.
Evolving a Clean, Pragmatic Architecture - A Craftsman's Guide
Evolving a Clean, Pragmatic Architecture - A Craftsman's GuideVictor Rentea This document outlines an agenda and presentation on clean code architecture. It discusses modeling data with entities and value objects, organizing logic by extracting services and applying the onion architecture. It emphasizes testing to reduce fear, and protecting developers through simplicity and avoiding overengineering. The presentation emphasizes keeping data transfer objects lightweight and external to the domain.
Hexagonal architecture for java applications
Hexagonal architecture for java applicationsFabricio Epaminondas The document discusses hexagonal architecture, also known as ports and adapters architecture. It is an alternative to traditional multi-layer architectures that aims to decouple the application core from external influences like databases, web frameworks, and other dependencies. The core domain logic is separated from external influences by defining application programming interfaces (APIs) called "ports" that external "adapters" implement. This allows the core to be developed and tested in isolation. The document provides an example implementation of a ticket management system using this architecture.
Clean coding-practices
Clean coding-practicesJohn Ferguson Smart Limited The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
Clean architecture - Protecting the Domain
Clean architecture - Protecting the DomainVictor Rentea The document discusses software architecture, focusing on key concepts like software structures, data encapsulation, and the importance of separating domain logic from external influences through various design principles. It emphasizes the need to create coherent boundaries within software systems, suggesting practices such as using value objects, managing Data Transfer Objects (DTOs), and applying the Dependency Inversion principle. The document also highlights practical architectural strategies for maintaining an agnostic domain that enhances testability and avoids vendor lock-in.
Clean Code I - Best Practices
Clean Code I - Best PracticesTheo Jungeblut The document discusses best practices for writing clean code, emphasizing the importance of maintainability, readability, and extensibility. Key principles include separation of concerns, the DRY (Don’t Repeat Yourself) principle, and SOLID principles, which promote better software design and architecture. Additionally, it highlights various resources and the significance of continuous learning and improvement in software craftsmanship.
Clean code
Clean codeMahmoud Zizo The document discusses principles of clean code, beginning with definitions of clean code from various authors. It outlines key principles like the single responsibility principle and open/closed principle. It then covers sections on meaningful naming, functions, and classes. For functions, it recommends they be small, do one thing, avoid flag arguments, and have no side effects. For classes, it advocates for small size, encapsulation, high cohesion and low coupling following the single responsibility principle.
Clean code
Clean codeArturo Herrero The document discusses the principles of clean code as articulated by various software engineering experts, emphasizing the importance of meaningful naming, simplicity, and readability in programming. It highlights practices such as adhering to the Boy Scout Rule, maintaining elegance in code, and ensuring functions handle a single responsibility while avoiding duplication. Additionally, the document critiques the use of comments, advocating for self-explanatory code and the avoidance of unnecessary or misleading comments.
Clean code and Code Smells
Clean code and Code SmellsMario Sangiorgio The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The aggregate is dead! Long live the aggregate! - SpringIO.pdf
The aggregate is dead! Long live the aggregate! - SpringIO.pdfSara Pellegrini The document discusses the concept of aggregates within domain-driven design, emphasizing their role in managing data consistency and boundaries for associated objects. It outlines practical applications and events in an education domain, particularly around course enrollment, capacity changes, and student subscriptions. The text addresses challenges related to refactoring, concurrency, and the integration of technical and business aspects within aggregate modeling.
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019Victor Rentea The document emphasizes the importance of embracing painful tasks in software development by either postponing, delegating, or facing them directly. It discusses agile practices, continuous integration, and architectural principles like the onion architecture while advocating for simplicity and minimizing overengineering. The talk also addresses the need for developer safety and comfort, encouraging practices such as pair programming and proper coding designs to enhance productivity and quality.
Clean architecture
Clean architectureandbed This document discusses clean architecture, which aims to separate an application into distinct layers. The core application logic is separated from the user interface and database access. This improves testability and flexibility. Some benefits of clean architecture include excellent testability since each component can be tested in isolation, clearly defined separation of concerns, and flexibility to change parts of the application independently. However, there are also costs like increased complexity with more classes and data conversions between layers.
Long running processes in DDD
Long running processes in DDDBernd Ruecker The document discusses the importance of managing long-running processes in software development, emphasizing the role of process managers that transform events into commands and handle state effectively. It critiques reliance on simplistic event notifications, which can obscure the larger operational flow and complicate debugging and modification. Additionally, it highlights challenges related to business requirements, such as payments and fulfillment for VIP customers, and advocates for programmatic or graphical flow definitions to enhance developer experience and system visibility.
Resilience4j with Spring Boot
Resilience4j with Spring BootKnoldus Inc. The document outlines a presentation on resilience4j, a fault tolerance library designed for Java 8 and functional programming, which offers various modules such as circuit breaker, retry, rate limiter, and bulkhead. Key concepts include the use of these modules to maintain service availability and resilience in distributed systems, along with implementation guidelines and example configurations. Attendees are reminded to provide feedback and respect session etiquette, including punctuality and minimizing disturbances.
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
Clean Code @Voxxed Days Cluj 2023 - opening KeynoteVictor Rentea The document explores the principles of clean code and its importance in software development, stressing practices like avoiding duplicated code and adhering to clean coding techniques for maintainability. It highlights common code smells and complexities, providing insights into improving code clarity and reliability through various methodologies. Additionally, the author shares personal experiences and resources for learning and applying clean coding practices effectively.
Functional Patterns with Java8 at Devoxx UK - Slides
Functional Patterns with Java8 at Devoxx UK - SlidesVictor Rentea The document is a presentation by Victor Rentea on functional programming patterns in Java 8, highlighting best practices such as using descriptive names, avoiding checked exceptions, and leveraging optional types. It includes various design patterns like the loan pattern and execute around pattern, emphasizing clean code principles and effective use of Java's functional features. The presentation encourages attendees to apply these patterns for better code maintainability and readability.
Clean Code with Java 8 - Functional Patterns and Best Practices
Clean Code with Java 8 - Functional Patterns and Best PracticesVictor Rentea Victor Rentea's presentation at Devoxx France focuses on clean code practices and Java 8 functional patterns, advocating for descriptive naming, small methods, and avoiding nulls through options. Key strategies include using lambdas effectively, executing around patterns, and managing resources with the loan pattern. The presentation emphasizes modern best practices in Java programming to enhance code readability and maintainability.
More Related Content
What's hot (20)
Clean Code
Clean CodeVictor Rentea This document by Victor Rentea focuses on the principles of clean code in enterprise Java, emphasizing the importance of readability, maintainability, and proper naming conventions. It covers various aspects such as the structure of functions, classes, and comments, advocating for small, self-explanatory methods and clear class designs to enhance team collaboration and code quality. The document also discusses advanced topics such as side effects, command/query separation, and the distinctions between objects and data structures to promote effective software development practices.
Clean pragmatic architecture @ devflix
Clean pragmatic architecture @ devflixVictor Rentea Victor Rentea introduces himself as a Java Champion, trainer, and speaker who focuses on topics like Hibernate, Spring, Java 8/FP, architecture, clean code, unit testing, reactive programming, and Java performance. He advocates building a deep, rich domain model with value objects and entities that encapsulate logic and enforce invariants. The document provides guidance on applying principles like separating concerns with layers, dependency inversion, and avoiding anemic domain models in order to build flexible, testable systems that are decoupled from frameworks and external dependencies.
clean code book summary - uncle bob - English version
clean code book summary - uncle bob - English versionsaber tabatabaee The document provides guidance on writing clean code based on the book "Clean Code" by Robert Cecil Martin. Some of the key points discussed include:
- Functions should do one thing and do it well, with a single level of abstraction and no side effects. They should fit on a screen.
- Names should be meaningful, avoid abbreviations, and use consistent vocabulary. Class names should be nouns and method names should be verbs.
- Code formatting is important for readability. Classes should not exceed 200 lines, functions a single screen. Variables should be declared near use.
- Comments should only explain why unusual decisions were made, not what the code does. Avoid commented out code or redundant comments
Extreme Professionalism - Software Craftsmanship
Extreme Professionalism - Software CraftsmanshipVictor Rentea This document discusses the concept of extreme professionalism in software craftsmanship, emphasizing the importance of understanding technologies, collective code ownership, and continuous learning. It contrasts the roles of developers and database administrators, highlights the challenges of overspecialization and overengineering, and stresses the need for better collaboration and practices in development. The author, Victor Rentea, outlines a 'software craftsperson's oath' that encourages high-quality coding, learning, and teamwork.
Software Craftsmanship @Code Camp Festival 2022.pdf
Software Craftsmanship @Code Camp Festival 2022.pdfVictor Rentea The document discusses the evolution of software craftsmanship and its importance in developing a technical culture among developers. It emphasizes the need for collective code ownership, continuous learning, and adapting to changing technologies to enhance developers' adaptability and effectiveness. Key concepts include overcoming overspecialization, promoting agile practices, and fostering environments that encourage collaboration and knowledge sharing.
Vertical Slicing Architectures
Vertical Slicing ArchitecturesVictor Rentea The document outlines a comprehensive training session by Victor Rentea, focusing on software architecture techniques including concentric architectures, vertical slicing, and microservices. It covers principles such as dependency inversion, testing strategies, and the importance of clear module boundaries, emphasizing best practices in designing scalable and maintainable software systems. Additionally, it addresses common pitfalls like overengineering and nano-services, while providing resources and examples for further understanding.
Evolving a Clean, Pragmatic Architecture - A Craftsman's Guide
Evolving a Clean, Pragmatic Architecture - A Craftsman's GuideVictor Rentea This document outlines an agenda and presentation on clean code architecture. It discusses modeling data with entities and value objects, organizing logic by extracting services and applying the onion architecture. It emphasizes testing to reduce fear, and protecting developers through simplicity and avoiding overengineering. The presentation emphasizes keeping data transfer objects lightweight and external to the domain.
Hexagonal architecture for java applications
Hexagonal architecture for java applicationsFabricio Epaminondas The document discusses hexagonal architecture, also known as ports and adapters architecture. It is an alternative to traditional multi-layer architectures that aims to decouple the application core from external influences like databases, web frameworks, and other dependencies. The core domain logic is separated from external influences by defining application programming interfaces (APIs) called "ports" that external "adapters" implement. This allows the core to be developed and tested in isolation. The document provides an example implementation of a ticket management system using this architecture.
Clean coding-practices
Clean coding-practicesJohn Ferguson Smart Limited The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
Clean architecture - Protecting the Domain
Clean architecture - Protecting the DomainVictor Rentea The document discusses software architecture, focusing on key concepts like software structures, data encapsulation, and the importance of separating domain logic from external influences through various design principles. It emphasizes the need to create coherent boundaries within software systems, suggesting practices such as using value objects, managing Data Transfer Objects (DTOs), and applying the Dependency Inversion principle. The document also highlights practical architectural strategies for maintaining an agnostic domain that enhances testability and avoids vendor lock-in.
Clean Code I - Best Practices
Clean Code I - Best PracticesTheo Jungeblut The document discusses best practices for writing clean code, emphasizing the importance of maintainability, readability, and extensibility. Key principles include separation of concerns, the DRY (Don’t Repeat Yourself) principle, and SOLID principles, which promote better software design and architecture. Additionally, it highlights various resources and the significance of continuous learning and improvement in software craftsmanship.
Clean code
Clean codeMahmoud Zizo The document discusses principles of clean code, beginning with definitions of clean code from various authors. It outlines key principles like the single responsibility principle and open/closed principle. It then covers sections on meaningful naming, functions, and classes. For functions, it recommends they be small, do one thing, avoid flag arguments, and have no side effects. For classes, it advocates for small size, encapsulation, high cohesion and low coupling following the single responsibility principle.
Clean code
Clean codeArturo Herrero The document discusses the principles of clean code as articulated by various software engineering experts, emphasizing the importance of meaningful naming, simplicity, and readability in programming. It highlights practices such as adhering to the Boy Scout Rule, maintaining elegance in code, and ensuring functions handle a single responsibility while avoiding duplication. Additionally, the document critiques the use of comments, advocating for self-explanatory code and the avoidance of unnecessary or misleading comments.
Clean code and Code Smells
Clean code and Code SmellsMario Sangiorgio The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The aggregate is dead! Long live the aggregate! - SpringIO.pdf
The aggregate is dead! Long live the aggregate! - SpringIO.pdfSara Pellegrini The document discusses the concept of aggregates within domain-driven design, emphasizing their role in managing data consistency and boundaries for associated objects. It outlines practical applications and events in an education domain, particularly around course enrollment, capacity changes, and student subscriptions. The text addresses challenges related to refactoring, concurrency, and the integration of technical and business aspects within aggregate modeling.
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019
Evolving a Clean, Pragmatic Architecture at JBCNConf 2019Victor Rentea The document emphasizes the importance of embracing painful tasks in software development by either postponing, delegating, or facing them directly. It discusses agile practices, continuous integration, and architectural principles like the onion architecture while advocating for simplicity and minimizing overengineering. The talk also addresses the need for developer safety and comfort, encouraging practices such as pair programming and proper coding designs to enhance productivity and quality.
Clean architecture
Clean architectureandbed This document discusses clean architecture, which aims to separate an application into distinct layers. The core application logic is separated from the user interface and database access. This improves testability and flexibility. Some benefits of clean architecture include excellent testability since each component can be tested in isolation, clearly defined separation of concerns, and flexibility to change parts of the application independently. However, there are also costs like increased complexity with more classes and data conversions between layers.
Long running processes in DDD
Long running processes in DDDBernd Ruecker The document discusses the importance of managing long-running processes in software development, emphasizing the role of process managers that transform events into commands and handle state effectively. It critiques reliance on simplistic event notifications, which can obscure the larger operational flow and complicate debugging and modification. Additionally, it highlights challenges related to business requirements, such as payments and fulfillment for VIP customers, and advocates for programmatic or graphical flow definitions to enhance developer experience and system visibility.
Resilience4j with Spring Boot
Resilience4j with Spring BootKnoldus Inc. The document outlines a presentation on resilience4j, a fault tolerance library designed for Java 8 and functional programming, which offers various modules such as circuit breaker, retry, rate limiter, and bulkhead. Key concepts include the use of these modules to maintain service availability and resilience in distributed systems, along with implementation guidelines and example configurations. Attendees are reminded to provide feedback and respect session etiquette, including punctuality and minimizing disturbances.
Clean Code @Voxxed Days Cluj 2023 - opening Keynote
Clean Code @Voxxed Days Cluj 2023 - opening KeynoteVictor Rentea The document explores the principles of clean code and its importance in software development, stressing practices like avoiding duplicated code and adhering to clean coding techniques for maintainability. It highlights common code smells and complexities, providing insights into improving code clarity and reliability through various methodologies. Additionally, the author shares personal experiences and resources for learning and applying clean coding practices effectively.
Similar to Functional Patterns with Java8 @Bucharest Java User Group (20)
Functional Patterns with Java8 at Devoxx UK - Slides
Functional Patterns with Java8 at Devoxx UK - SlidesVictor Rentea The document is a presentation by Victor Rentea on functional programming patterns in Java 8, highlighting best practices such as using descriptive names, avoiding checked exceptions, and leveraging optional types. It includes various design patterns like the loan pattern and execute around pattern, emphasizing clean code principles and effective use of Java's functional features. The presentation encourages attendees to apply these patterns for better code maintainability and readability.
Clean Code with Java 8 - Functional Patterns and Best Practices
Clean Code with Java 8 - Functional Patterns and Best PracticesVictor Rentea Victor Rentea's presentation at Devoxx France focuses on clean code practices and Java 8 functional patterns, advocating for descriptive naming, small methods, and avoiding nulls through options. Key strategies include using lambdas effectively, executing around patterns, and managing resources with the loan pattern. The presentation emphasizes modern best practices in Java programming to enhance code readability and maintainability.
Functional Programming Patterns with Java 8 (at Devoxx BE)
Functional Programming Patterns with Java 8 (at Devoxx BE)Victor Rentea The document is a presentation by Victor Rentea on functional programming patterns using Java 8, showcasing his expertise as a technical trainer and architect. It discusses various programming principles and patterns such as avoiding nulls, using optional values, and implementing clean code practices. Additionally, it promotes a DZone article for further reading on the topic.
Functional Programming in Java - Code for Maintainability
Functional Programming in Java - Code for MaintainabilityMarcin Stepien The document discusses the principles of functional programming in Java, emphasizing maintainability through techniques such as code clarity, reusability, and separation of concerns. It highlights features introduced in Java 8 like lambda expressions and streams, detailing their benefits for writing cleaner and more expressive code. Practical examples illustrate how to implement functional programming concepts to improve code maintainability and reduce verbosity.
Functional Programming 101 for Java 7 Developers
Functional Programming 101 for Java 7 DevelopersJayaram Sankaranarayanan The document discusses functional and reactive programming concepts, particularly for Java 7 developers, emphasizing the importance of pure functions, immutability, and strong static typing. It highlights the benefits of functional programming, such as testability, readability, and maintainability, while also addressing the significance of reactive systems and their traits like responsiveness and resiliency. Furthermore, it provides practical examples and best practices for implementing these programming paradigms effectively in software development.
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressi...
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressi...coriehokitiw Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressions Venkat Subramaniam
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressions Venkat Subramaniam
Functional Programming In Java Harnessing The Power Of Java 8 Lambda Expressions Venkat Subramaniam
Beyond PITS, Functional Principles for Software Architecture
Beyond PITS, Functional Principles for Software ArchitectureJayaram Sankaranarayanan This document discusses functional principles in software architecture, primarily focusing on concepts applicable to users familiar with object-oriented programming in languages like Java and C++. It emphasizes the importance of pure functions, immutability, and function composition while providing examples and discussing the implications for system design and architecture. Key recommendations include isolating state management, maintaining a high ratio of pure functions, and adopting functional programming constructs and libraries.
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Func...
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Func...romergalbowx A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles 1st Edition Ben Weidig
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles 1st Edition Ben Weidig
A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles 1st Edition Ben Weidig
Designing function families and bundles with java's behaviors parameterisatio...
Designing function families and bundles with java's behaviors parameterisatio...Alain Lompo The document discusses the design of function families and bundles using Java's behavior parameterization and lambdas, emphasizing the challenges of changing user requirements during implementation. It highlights the benefits of functional programming, including reduced software maintenance costs, simpler code, and happier developers, while introducing core concepts such as lambda expressions and functional interfaces. Additionally, it explores design patterns like strategy and command patterns to parameterize behaviors effectively in software development.
Refactoring Games - 15 things to do after Extract Method
Refactoring Games - 15 things to do after Extract MethodVictor Rentea The document outlines 15 specific refactoring strategies after applying the extract method technique in software development. It emphasizes best practices for cleaner code, including renaming variables, encapsulating conditionals, and avoiding boolean parameters. The author, Victor Rentea, shares insights from his experience as a technical trainer and promotes participation in coding communities and meetups.
Do you even Function? Guiding Through Functional Interfaces
Do you even Function? Guiding Through Functional InterfacesDmitry Vinnik The document discusses functional programming concepts in Java including streams, optional, high order functions like predicate and supplier. It covers designing for functional programming through principles like immutable data and lazy evaluation. Examples show imperative vs declarative styles and how to use method references and custom functional interfaces. Common use cases like error handling and multi-dimensional data are demonstrated. Finally, antipatterns of functional programming are mentioned.
Scala: functional programming for the imperative mind
Scala: functional programming for the imperative mindSander Mak (@Sander_Mak) Scala is a programming language that runs on the JVM and fuses functional and object-oriented paradigms. It aims to provide functional programming for programmers with an imperative mindset. Key features include functions as first-class values, pattern matching, traits for composition, and seamless interoperability with Java. While some features appear to be language features, many are actually implemented via libraries. The Scala community is growing with adoption by companies and increasing support in tools and publications.
Java and effective programming. Is it possible? - IAESTE Case Week 2016
Java and effective programming. Is it possible? - IAESTE Case Week 2016Łukasz Koniecki The document outlines a workshop focused on effective Java programming, highlighting good design practices, common anti-patterns, and practical coding exercises. It emphasizes the importance of design patterns, functional programming principles, and generics, along with the need for developers to understand Java's stream API. Additionally, it includes specifications for implementing methods to solve specific problems, reinforcing best practices in Java development.
Effective programming in Java - Kronospan Job Fair 2016
Effective programming in Java - Kronospan Job Fair 2016Łukasz Koniecki The workshop focused on effective programming in Java, covering design patterns, functional programming, and generics. Participants learned to solve common programming problems and avoided anti-patterns while gaining insights into performance management. Key exercises included implementing methods for grouping strings and creating union sets, emphasizing best practices and type safety.
What is Pure Functional Programming, and how it can improve our application t...
What is Pure Functional Programming, and how it can improve our application t...Luca Molteni The document discusses pure functional programming and its benefits for application testing, highlighting concepts like referential transparency and the differences between pure and impure functions. It emphasizes how pure functional programming can lead to more testable code through strong type systems and proper testing methodologies. The conclusion suggests that while pure functional programming improves code quality, it is also essential to complement it with tests to effectively catch bugs.
About Functional Programming
About Functional ProgrammingAapo Kyrölä The document discusses the limitations of object-oriented programming (OOP) in Java, outlining issues like null pointers, cumbersome class hierarchies, and the difficulties of inheritance. It introduces functional programming (FP) concepts, emphasizing its advantages such as immutability, higher-order functions, and a strong type system, while also noting its historical context and evolution alongside imperative languages. Additionally, the document explores practical functional programming applications in Java, advocating for a shift towards functional principles to enhance code robustness and maintainability.
Functional programming with Java 8
Functional programming with Java 8Talha Ocakçı Functional programming in Java 8 allows for:
1) The use of lambda expressions and streams for a more declarative programming style without iteration.
2) Functional interfaces like Function, Predicate, and Consumer along with lambda expressions enable function composition and chaining.
3) Features like immutable collections help reduce mutability and side effects, important aspects of functional programming.
Thinking Functionally
Thinking FunctionallyPiyush Katariya This document provides an opinionated guide to thinking functionally as a software architect. It recommends starting with Racket to learn functional programming concepts like recursion, higher order functions, and avoiding mutations. Some key aspects of functional programming discussed are using functions as first-class citizens, favoring recursion over iteration, laziness with streams, expressions over statements, and composition over inheritance. The document also mentions concepts like closures, pattern matching, currying, and persistent data structures. It recommends resources for learning more about functional programming in Racket, Lisp, Haskell, F#, OCaml, and Idris.
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cov...
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cov...politomuqeem Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cover Petri Siln
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cover Petri Siln
Clean Code Principles And Patterns A Software Practitioners Handbook 1 No Cover Petri Siln
Definitive Guide to Working With Exceptions in Java
Definitive Guide to Working With Exceptions in JavaVictor Rentea This document serves as a comprehensive guide on working with exceptions in Java, emphasizing the importance of exception handling strategies such as logging and using runtime exceptions. It discusses historical context, best practices, and patterns to effectively manage exceptions in Java applications, while also tackling common anti-patterns. Additionally, it highlights the use of features introduced in recent Java versions, such as Optional and functional interfaces.
Ad
More from Victor Rentea (20)
Top REST API Desgin Pitfalls @ Devoxx 2024
Top REST API Desgin Pitfalls @ Devoxx 2024Victor Rentea Victor Rentea outlines key pitfalls in REST API design, emphasizing the importance of versioning, exposing only Data Transfer Objects (DTOs), and avoiding breaking changes. He advises on effective strategies such as separating commands from queries, utilizing bulk operations, and enhancing APIs with sub-resources and verbs. The document stresses that careful design can improve client experience and mitigate common issues faced in API development.
The Joy of Testing - Deep Dive @ Devoxx Belgium 2024
The Joy of Testing - Deep Dive @ Devoxx Belgium 2024Victor Rentea The document provides an extensive overview of best practices in unit testing, covering topics such as test qualities, coverage management, mutation testing, and BDD methodologies. It emphasizes the importance of meaningful test names, the use of tools like AssertJ, and strategies for testing legacy code, alongside real-world examples from the speaker's extensive experience. The coding resources mentioned are available on GitHub, highlighting a hands-on approach to learning testing techniques.
Finding Java's Hidden Performance Traps @ DevoxxUK 2024
Finding Java's Hidden Performance Traps @ DevoxxUK 2024Victor Rentea The document discusses performance profiling in Java applications, focusing on distributed request tracing and execution profiling. It outlines methodologies, including the use of trace IDs for tracking requests, and tools like Micrometer and Java Flight Recorder for monitoring performance metrics. Key challenges and common performance pitfalls are highlighted, along with examples of how to resolve them effectively.
Modular Monolith - a Practical Alternative to Microservices @ Devoxx UK 2024
Modular Monolith - a Practical Alternative to Microservices @ Devoxx UK 2024Victor Rentea Victor Rentea discusses the benefits and challenges of using a modulith architecture as an alternative to microservices, highlighting its ability to balance complexity and productivity. He emphasizes starting with a simple monolith and gradually decoupling it into modules as needed, rather than jumping directly into microservices. The document also touches on the importance of proper code and data isolation, as well as the need for effective testing and monitoring in modular systems.
Microservice Resilience Patterns @VoxxedCern'24
Microservice Resilience Patterns @VoxxedCern'24Victor Rentea The document discusses resilience patterns for microservices, emphasizing the importance of handling unexpected situations with minimal user impact and graceful degradation. It outlines various strategies including isolation, bulkheads, circuit breakers, and idempotency that help maintain system availability and performance under failure conditions. The author, Victor Rentea, also highlights the significance of monitoring, asynchronous communication, and eventual consistency in building resilient systems.
Distributed Consistency.pdf
Distributed Consistency.pdfVictor Rentea The document discusses various strategies for maintaining consistency in distributed systems, focusing on techniques such as 2-phase commit (2PC), transactional outbox patterns, and saga patterns for managing transactions across multiple services. It highlights the challenges associated with these approaches, including potential failures and the need for idempotency in operations. Additionally, it provides practical scenarios and examples related to message queuing, event handling, and state management in the context of microservices architecture.
Testing Microservices @DevoxxBE 23.pdf
Testing Microservices @DevoxxBE 23.pdfVictor Rentea Victor Rentea offers training on testing microservices, sharing insights on unit testing, integration testing, and the challenges of flaky and slow tests. He emphasizes the importance of decoupling tests and using real environments to enhance test reliability, suggesting various strategies to improve testing efficiency and reduce cognitive load. The document highlights key techniques such as contract testing and using Docker for a production-like setup.
From Web to Flux @DevoxxBE 2023.pptx
From Web to Flux @DevoxxBE 2023.pptxVictor Rentea Victor Rentea, a Java champion with extensive experience in clean coding and reactive programming, offers insights into reactive programming as a way to handle asynchronous data streams. He emphasizes the use of Project Reactor for backend Java applications and provides practical advice on transitioning from imperative to reactive programming. The document outlines best practices, operator handling, and the benefits of virtual threads in managing high concurrency without the typical risks associated with reactive programming.
Test-Driven Design Insights@DevoxxBE 2023.pptx
Test-Driven Design Insights@DevoxxBE 2023.pptxVictor Rentea The document provides insights into test-driven design and best practices for unit testing, emphasizing the importance of emergent design, minimalism, and the effective use of mocks. It critiques common pitfalls such as overengineering and the misuse of mocks, advocating for clear responsibilities in code and functional programming principles. Additionally, the author discusses the evolution of testing strategies and the need for clarity in unit tests to promote better design and maintainable code.
Profiling your Java Application
Profiling your Java ApplicationVictor Rentea This document discusses Java application profiling, covering tools and techniques for identifying performance issues such as slow endpoint response times and connection starvation. It highlights the use of Micrometer for monitoring system metrics, Java Flight Recorder for profiling, and provides practical examples of how to implement these tools in applications. The content also addresses challenges in distributed systems and emphasizes the importance of proper profiling and monitoring for optimizing performance.
OAuth in the Wild
OAuth in the WildVictor Rentea OAuth (Open Authorization) is an open standard for access delegation that allows users to grant applications access to their data on other platforms without sharing passwords. The framework enables third-party apps to request limited access to a user's information, implementing key steps such as obtaining an authorization code and using it to acquire an access token. Various security attacks and vulnerabilities, such as open redirects and token leakage, are discussed, highlighting the importance of proper implementation to safeguard user data.
Unit testing - 9 design hints
Unit testing - 9 design hintsVictor Rentea Victor Rentea discusses design improvements revealed through unit testing, emphasizing the importance of writing responsible tests to enhance design skills. Key concepts include the CQS principle, using mocks wisely, and maintaining separation of complexity in design. The talk also highlights the role of pure functions and immutable objects in creating better testable code.
Refactoring blockers and code smells @jNation 2021
Refactoring blockers and code smells @jNation 2021Victor Rentea The document discusses the importance of refactoring in software development, highlighting techniques for code improvement without altering its external behavior. It emphasizes safe refactoring practices, overcoming challenges such as legacy code, and the benefits of incremental changes and collaboration. The content also touches on common code smells and offers strategies for efficient development habits and maintaining code quality.
Hibernate and Spring - Unleash the Magic
Hibernate and Spring - Unleash the MagicVictor Rentea This document provides an overview of several Java technologies:
- JPA Auditing for tracking entity creation/modification dates and users
- Domain Events in DDD for triggering processing across aggregates
- javax.validation for validating entities before database writes
- Spring Data Repos for implementing repositories with query methods and custom logic
It also briefly discusses JPA auditing implementation, domain event publishing, custom validators, and the @NonNullApi annotation for preventing null returns from repositories.
Integration testing with spring @JAX Mainz
Integration testing with spring @JAX MainzVictor Rentea The document provides an extensive guide on integration testing using Spring, detailing various best practices, tools, and techniques. It emphasizes the importance of managing test failures, optimizing test speeds, and using mock objects effectively within a Spring context. Additionally, it covers database interactions and suggests methods for organizing tests and data fixtures to streamline development processes.
The Proxy Fairy and the Magic of Spring @JAX Mainz 2021
The Proxy Fairy and the Magic of Spring @JAX Mainz 2021Victor Rentea Victor Rentea is an independent trainer and founder of the Bucharest Software Craftsmanship Community, specializing in Java and Spring framework training. He highlights the importance of dependency injection, proxies in Spring, and the limitations of Aspect-Oriented Programming (AOP). The document also discusses performance details related to caching and the writing of custom aspects in Spring AOP.
Pure functions and immutable objects @dev nexus 2021
Pure functions and immutable objects @dev nexus 2021Victor Rentea The document discusses the principles of functional programming, particularly focusing on pure functions, immutability, and the importance of avoiding side effects in code. It emphasizes the benefits of pure functions such as transparency, ease of testing, and composability, while also addressing the challenges of enforcing purity in programming languages like Java. Additionally, it explores the role of immutable objects and their impact on data management and application design.
TDD Mantra
TDD MantraVictor Rentea This document describes Victor Rentea, an independent trainer and founder of the Bucharest Software Craftsmanship Community who has provided technical training to over 2000 developers over 8 years. It promotes Victor Rentea's training services on topics like Hibernate, Spring, Java performance, reactive programming, design patterns, clean code, refactoring, and unit testing in any language. The document also provides brief summaries of test-driven development and the three rules of TDD according to Uncle Bob, as well as a definition of code golf.
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...
Definitive Guide to Working With Exceptions in Java - takj at Java Champions ...Victor Rentea The document outlines concepts and best practices for handling exceptions in Java, emphasizing the differences between checked and unchecked exceptions and the importance of proper error logging and user-friendly messaging. It introduces patterns like catch-rethrow and suggests using runtime exceptions to simplify error handling. Additionally, it provides resources for further reading on exception management and Java programming techniques.
Pure Functions and Immutable Objects
Pure Functions and Immutable ObjectsVictor Rentea The document discusses the principles of pure functions and immutability in programming, emphasizing the advantages of pure functions in terms of easier understanding, testing, and parallelization. It presents methods for purifying logic and reducing side effects in code, encouraging the avoidance of mutable objects for better data management and to prevent bugs. Additionally, it outlines situations where immutability may not be beneficial and offers takeaways for implementing these concepts effectively in software development.
Ad
Recently uploaded (20)
Who will create the languages of the future?
Who will create the languages of the future?Jordi Cabot Will future languages be created by language engineers?
Can you "vibe" a DSL?
In this talk, we will explore the changing landscape of language engineering and discuss how Artificial Intelligence and low-code/no-code techniques can play a role in this future by helping in the definition, use, execution, and testing of new languages. Even empowering non-tech users to create their own language infrastructure. Maybe without them even realizing.
Transmission Media. (Computer Networks)
Transmission Media. (Computer Networks)S Pranav (Deepu) INTRODUCTION:TRANSMISSION MEDIA
• A transmission media in data communication is a physical path between the sender and
the receiver and it is the channel through which data can be sent from one location to
another. Data can be represented through signals by computers and other sorts of
telecommunication devices. These are transmitted from one device to another in the
form of electromagnetic signals. These Electromagnetic signals can move from one
sender to another receiver through a vacuum, air, or other transmission media.
Electromagnetic energy mainly includes radio waves, visible light, UV light, and gamma
ra
Open Source Software Development Methods
Open Source Software Development MethodsVICTOR MAESTRE RAMIREZ Open Source Software Development Methods
AI-Powered Compliance Solutions for Global Regulations | Certivo
AI-Powered Compliance Solutions for Global Regulations | Certivocertivoai Certivo offers AI-powered compliance solutions designed to help businesses in the USA, EU, and UK simplify complex regulatory demands. From environmental and product compliance to safety, quality, and sustainability, our platform automates supplier documentation, manages certifications, and integrates with ERP/PLM systems. Ensure seamless RoHS, REACH, PFAS, and Prop 65 compliance through predictive insights and multilingual support. Turn compliance into a competitive edge with Certivo’s intelligent, scalable, and audit-ready platform.
MOVIE RECOMMENDATION SYSTEM, UDUMULA GOPI REDDY, Y24MC13085.pptx
MOVIE RECOMMENDATION SYSTEM, UDUMULA GOPI REDDY, Y24MC13085.pptxMaharshi Mallela Movie recommendation system is a software application or algorithm designed to suggest movies to users based on their preferences, viewing history, or other relevant factors. The primary goal of such a system is to enhance user experience by providing personalized and relevant movie suggestions.
Code and No-Code Journeys: The Coverage Overlook
Code and No-Code Journeys: The Coverage OverlookApplitools Explore practical ways to expand visual and functional UI coverage without deep coding or heavy maintenance in this session. Session recording and more info at applitools.com
Making significant Software Architecture decisions
Making significant Software Architecture decisionsBert Jan Schrijver Presented at the iSAQB Software Architecture Community NL meetup on 12-6-2025
wAIred_RabobankIgniteSession_12062025.pptx
wAIred_RabobankIgniteSession_12062025.pptxSimonedeGijt In today's world, artificial intelligence (AI) is transforming the way we learn.
This talk will explore how we can use AI tools to enhance our learning experiences, by looking at some (recent) research that has been done on the matter.
But as we embrace these new technologies, we must also ask ourselves:
Are we becoming less capable of thinking for ourselves?
Do these tools make us smarter, or do they risk dulling our critical thinking skills?
This talk will encourage us to think critically about the role of AI in our education. Together, we will discover how to use AI to support our learning journey while still developing our ability to think critically.
Agile Software Engineering Methodologies
Agile Software Engineering MethodologiesGaurav Sharma Software Engineering Process, Notation & Tools Introduction
Women in Tech: Marketo Engage User Group - June 2025 - AJO with AWS
Women in Tech: Marketo Engage User Group - June 2025 - AJO with AWSBradBedford3 Creating meaningful, real-time engagement across channels is essential to building lasting business relationships. Discover how AWS, in collaboration with Deloitte, set up one of Adobe's first instances of Journey Optimizer B2B Edition to revolutionize customer journeys for B2B audiences.
This session will share the use cases the AWS team has the implemented leveraging Adobe's Journey Optimizer B2B alongside Marketo Engage and Real-Time CDP B2B to deliver unified, personalized experiences and drive impactful engagement.
They will discuss how they are positioning AJO B2B in their marketing strategy and how AWS is imagining AJO B2B and Marketo will continue to work together in the future.
Whether you’re looking to enhance customer journeys or scale your B2B marketing efforts, you’ll leave with a clear view of what can be achieved to help transform your own approach.
Speakers:
Britney Young Senior Technical Product Manager, AWS
Erine de Leeuw Technical Product Manager, AWS
Shell Skill Tree - LabEx Certification (LabEx)
Shell Skill Tree - LabEx Certification (LabEx)VICTOR MAESTRE RAMIREZ Shell Skill Tree - LabEx Certification (LabEx)
Migrating to Azure Cosmos DB the Right Way
Migrating to Azure Cosmos DB the Right WayAlexander (Alex) Komyagin In this session we cover the benefits of a migration to Cosmos DB, migration paths, common pain points and best practices. We share our firsthand experiences and customer stories. Adiom is the trusted partner for migration solutions that enable seamless online database migrations from MongoDB to Cosmos DB vCore, and DynamoDB to Cosmos DB for NoSQL.
Software Testing & it’s types (DevOps)
Software Testing & it’s types (DevOps)S Pranav (Deepu) NTRODUCTION TO SOFTWARE TESTING
• Definition:
• Software testing is the process of evaluating and
verifying that a software application or system meets
specified requirements and functions correctly.
• Purpose:
• Identify defects and bugs in the software.
• Ensure the software meets quality standards.
• Validate that the software performs as intended in
various scenarios.
• Importance:
• Reduces risks associated with software failures.
• Improves user satisfaction and trust in the product.
• Enhances the overall reliability and performance of
the software
Generative Artificial Intelligence and its Applications
Generative Artificial Intelligence and its ApplicationsSandeepKS52 The exploration of generative AI begins with an overview of its fundamental concepts, highlighting how these technologies create new content and ideas by learning from existing data. Following this, the focus shifts to the processes involved in training and fine-tuning models, which are essential for enhancing their performance and ensuring they meet specific needs. Finally, the importance of responsible AI practices is emphasized, addressing ethical considerations and the impact of AI on society, which are crucial for developing systems that are not only effective but also beneficial and fair.
Software Engineering Process, Notation & Tools Introduction - Part 3
Software Engineering Process, Notation & Tools Introduction - Part 3Gaurav Sharma Software Engineering Process, Notation & Tools Introduction
Smadav Pro 2025 Rev 15.4 Crack Full Version With Registration Key
Smadav Pro 2025 Rev 15.4 Crack Full Version With Registration Keyjoybepari360 ➡️ 🌍📱👉COPY & PASTE LINK👉👉👉
https://crackpurely.site/smadav-pro-crack-full-version-registration-key/
Functional Patterns with Java8 @Bucharest Java User Group
- 1. #DevoxxUK @victorrentea Functional Programming Patterns with Java 8 - live coding marathon - Victor Rentea IBM Lead Architect & Independent Trainer [email protected] www.VictorRentea.ro All the commits will be pushed to https://github.com/victorrentea/functional-patterns-bjug-2018.git
- 3. Victor Rentea 13 years of Java Lead Architect at IBM Tech Team Lead and Consultant Clean Code Evangelist [email protected] www.VictorRentea.ro Moscow Paris London Krakow Vienna Sofia Casablanca Bucharest Belgrade Kiew Barcelona
- 4. victorrentea.ro @victorrentea Spring Hibernate Clean Code, Architectures Java 8, Design Patterns Unit Testing Java Performance Scala & more... Independent Technical Trainer & Coach [email protected] VictorRentea.ro 1000+ devs 5 years tough clients:
- 9. victorrentea.ro @victorrentea Let's CODE !! 9 I'll push everything here: https://github.com/victorrentea/functional-patterns-devoxx-uk
- 11. victorrentea.ro @victorrentea The Clean Code Rules Applied to Java 8 11
- 12. victorrentea.ro @victorrentea Descriptive Names Best Lambdas are fit, thin one-liners Extract heavy lambdas into named ::methods in the same class in the item class as static methods -> {a-nonymous functions 12 Lambdas
- 13. victorrentea.ro @victorrentea Stream Wrecks 1 usecase = 1 single chain of 30 function calls. Don't do that ! We beg you ! We have children, families,… Break them using explanatory variables Small Methods Five Lines 13
- 14. victorrentea.ro @victorrentea Optional Instead: thatOpt.map(myFunction) No NullableParameters Avoid Returning Null,Throw Ex … or return an Optional PS: don't be afraid of Orcs, Monads, or .flatMap 14
- 15. victorrentea.ro @victorrentea Passing-a-Block Pass logic to your function The Funeral of Template Method™ 15
- 16. victorrentea.ro @victorrentea Loan Pattern You work with a resource that is managed for you Decouples real logic from infra code 16
- 17. victorrentea.ro @victorrentea Execute Around Pattern Explicit AOP ~ Proxy™ or Decorator™ 17
- 18. victorrentea.ro @victorrentea Avoid Checked Exceptions java.util.function interfaces don't declare any throws Which is good ! You must suffer if you work with non-Runtime Exceptions! But if you insist: - Define throwing functional interfaces - Use libraries: jool, vavr... 18
- 19. victorrentea.ro @victorrentea Type-specific Logic switch Switch Hunt Day® Hope to find them all: JDD Simplest to Read 1 switch = 1 method case XX: return … OOP Extends is BAD ONE Shot Children90Movie enum Isolated Logic In enum methods Logic with Dependencies Function references on enums (bean passed as param) 19
- 20. victorrentea.ro @victorrentea Thank You! 20 Disclaimer: The use of ® or ™ is the slides is only anecdotic. So good we can ask more explanations after the Pizza What was that??
- 21. victorrentea.ro @victorrentea Thank You! 21 Disclaimer: The use of ® or ™ is the slides is only anecdotic. [email protected] www.VictorRentea.ro Let's Chat:
- 22. victorrentea.ro @victorrentea Thank You! I'm available a statement of seniority I use both hemispheres Tough meetings? Abused estimates? Purpose of code: 1. Maintainable -- Uncle Bob Functional Party Activist Stay into The Light I brought you some Motivational Stickers In-house/remote training or coaching? What do You want us to do the second hour? (after the Pizza) victorrentea.ro/vote.html Dissect some examples Basic Java8 Tutorial (Slow-motion) Mocking Kata TDD Kata Spring @Transactional [email protected] www.VictorRentea.ro