Power-Up Your Test Suite with OLE Automation by Joshua RussellQA or the Highway
- Power-Up Your Test Suite With OLE Automation discusses using OLE Automation and the combination of Ruby and WIN32OLE for test automation of native Windows applications like Excel, Internet Explorer, and mainframe terminal emulators.
- OLE Automation allows automation of tasks on Windows applications through Microsoft's Automation interface when other popular options are unavailable. It provides access to an application's functionality through objects, properties, methods.
- Specific examples are provided for automating Excel workbooks and worksheets, controlling a mainframe terminal emulator, and integrating the automation into Cucumber scenarios. The presentation aims to demonstrate how OLE Automation can help "power up" a test suite.
Design patterns provide common templates for solving similar problems. They also provide a higher-level language for software developers to use to describe approaches they might choose when designing part of an application. This session introduces and applies several patterns useful to web application developers. Examples will primarily use C#/.NET.
Automate Your Data, Free Your Mind by Aaron SwerleinQA or the Highway
This document provides an overview of database automation using the Ruby Gem Sequel. It discusses using Sequel to connect to databases, define models and tables, and perform CRUD operations. Examples are provided for setting up connections, querying with SQL and Ruby methods, and running tests with Cucumber. Benefits covered include increased speed, coverage, and maintaining living documentation.
"Refactoring to SOLID Code" session presentation from
Emerging .NET Devs - October 2011 User Group Meeting.
Please note that this presentation has been simplified for publishing.
Drupal and its contributed modules provides an impressive amount of functionality without needing to write a single line of code by storing information in Drupal’s database tables. Unfortunately this poses a challenge for developers wanting to stage changes between servers. This talk starts to address these issues by describing the problem and presenting a variety of solutions as well as their pros and cons. I also discuss some possible paths to make this easier coming down the pipe.
This document provides an overview of managing databases using Entity Framework Core and Code First Migrations. It discusses using the Fluent API for mapping entity classes to database tables. Code First Migrations allows managing the development cycle between code and the database by generating scripts to synchronize schema changes. Migrations create snapshots of the database that allow migrating and scripting SQL changes between different points in development.
The document discusses principles of effective API design. It begins by defining an API as providing a way for developers to interact with and consume a service. Some key principles discussed include:
1. Designing the API first before implementing backend logic to focus on usability.
2. Choosing an appropriate runtime that allows for scalability, reliability and hybrid cloud/on-premise deployment.
3. Using API contracts to define and enforce policies and service level agreements with consumers.
4. Monitoring API usage over time to understand usage patterns and improve the consumer experience.
5. Iteratively improving APIs through continuous feedback to optimize them over time.
6. Socializing APIs by creating developer port
Many developers forget about good object-oriented design techniques when developing in SharePoint, most of the time because they get overwhelmed by the framework. Unit testing often gets thrown out of the window, and most of the time the application becomes very tightly coupled to the SharePoint object model. This talk will demonstrate how to overcome these obstacles and build solid SharePoint application code that is much more testable and is easier to maintain.
Power-Up Your Test Suite with OLE Automation by Joshua RussellQA or the Highway
- Power-Up Your Test Suite With OLE Automation discusses using OLE Automation and the combination of Ruby and WIN32OLE for test automation of native Windows applications like Excel, Internet Explorer, and mainframe terminal emulators.
- OLE Automation allows automation of tasks on Windows applications through Microsoft's Automation interface when other popular options are unavailable. It provides access to an application's functionality through objects, properties, methods.
- Specific examples are provided for automating Excel workbooks and worksheets, controlling a mainframe terminal emulator, and integrating the automation into Cucumber scenarios. The presentation aims to demonstrate how OLE Automation can help "power up" a test suite.
Design patterns provide common templates for solving similar problems. They also provide a higher-level language for software developers to use to describe approaches they might choose when designing part of an application. This session introduces and applies several patterns useful to web application developers. Examples will primarily use C#/.NET.
Automate Your Data, Free Your Mind by Aaron SwerleinQA or the Highway
This document provides an overview of database automation using the Ruby Gem Sequel. It discusses using Sequel to connect to databases, define models and tables, and perform CRUD operations. Examples are provided for setting up connections, querying with SQL and Ruby methods, and running tests with Cucumber. Benefits covered include increased speed, coverage, and maintaining living documentation.
"Refactoring to SOLID Code" session presentation from
Emerging .NET Devs - October 2011 User Group Meeting.
Please note that this presentation has been simplified for publishing.
Drupal and its contributed modules provides an impressive amount of functionality without needing to write a single line of code by storing information in Drupal’s database tables. Unfortunately this poses a challenge for developers wanting to stage changes between servers. This talk starts to address these issues by describing the problem and presenting a variety of solutions as well as their pros and cons. I also discuss some possible paths to make this easier coming down the pipe.
This document provides an overview of managing databases using Entity Framework Core and Code First Migrations. It discusses using the Fluent API for mapping entity classes to database tables. Code First Migrations allows managing the development cycle between code and the database by generating scripts to synchronize schema changes. Migrations create snapshots of the database that allow migrating and scripting SQL changes between different points in development.
The document discusses principles of effective API design. It begins by defining an API as providing a way for developers to interact with and consume a service. Some key principles discussed include:
1. Designing the API first before implementing backend logic to focus on usability.
2. Choosing an appropriate runtime that allows for scalability, reliability and hybrid cloud/on-premise deployment.
3. Using API contracts to define and enforce policies and service level agreements with consumers.
4. Monitoring API usage over time to understand usage patterns and improve the consumer experience.
5. Iteratively improving APIs through continuous feedback to optimize them over time.
6. Socializing APIs by creating developer port
Many developers forget about good object-oriented design techniques when developing in SharePoint, most of the time because they get overwhelmed by the framework. Unit testing often gets thrown out of the window, and most of the time the application becomes very tightly coupled to the SharePoint object model. This talk will demonstrate how to overcome these obstacles and build solid SharePoint application code that is much more testable and is easier to maintain.
Improving the Design of Existing SoftwareSteven Smith
The document discusses improving the design of existing software by following principles like DRY, SOLID, and refactoring code using techniques such as extracting classes, methods, and interfaces. It emphasizes writing characterization tests to preserve existing behavior when refactoring, and improving code quality by reducing duplication, dependencies, and complexity over time through preventative maintenance and refactoring.
Originally this was proposed as "88 Slides About 44 Modules" but it was scaled back to "44 Slides About 22 Modules". It was meant as a quick and dirty introduction to small niche / utility modules that people may not have been aware of (with a couple hardcore useful dev modules mixed in.)
Introducing domain driven design - dogfood con 2018Steven Smith
DDD provides a set of patterns and practices for tackling complex business problems with software models. Learn the basics of DDD in this session, including several principles and patterns you can start using immediately even if your project hasn't otherwise embraced DDD. Examples will primarily use C#/.NET.
This document discusses JRebel, a tool that allows developers to see code changes in web applications without redeploying. It summarizes JRebel's key features, licensing options, and how it works by redefining classes at runtime using instrumentation and bytecode handling to allow reloading updated classes. It then demonstrates how JRebel can be used with GateIn to achieve zero-redeployment of portlets and UI components.
Design Pattern Mastery - Momentum Dev Con 19 Apr 2018Steven Smith
Design patterns help developers and teams solve problems using proven approaches. In this talk, you'll learn how to solve a series of real world problems by applying patterns. Not only do patterns help individual developers solve particular problems, but they also enable teams to discuss design decisions using a richer, more descriptive language. By the end, you'll have some concrete tools you can apply, and hopefully the desire to master more patterns as you continue to improve!
"Architecting and testing large iOS apps: lessons from Facebook". Adam Ernst,...Yandex
In 2012 Facebook relaunched their iOS app to use native code. This was a big shift in architecting and implementing the Facebook app experience, the most widely used third party app on the entire iOS platform. Adam Ernst will speak about how the decision was made to switch to native code and how the company prepared to rewrite the app. He will share an inside look at the APIs and technical architecture Facebook uses to enable dozens of iOS developers to work on the same application. Automated testing is very important to Facebook, so Adam will also speak about how Facebook uses testing on iOS to keep the app reliable.
Do we need SOLID principles during software development?Anna Shymchenko
The document discusses the SOLID principles of object-oriented design. It defines each principle - Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. It also addresses common project design issues SOLID principles can help solve like instability, immobility, and complexity. Both benefits and potential disadvantages of SOLID like an overuse of abstractions or small modules are presented.
The document discusses executable requirements and behavior-driven development (BDD). It defines what makes a good requirement and gives examples of use cases, user stories, and traceability matrices. The presentation argues that executable requirements in BDD tools like SpecFlow help ensure requirements are testable and prevent issues like missed requirements or developer misinterpretation. It demonstrates writing executable requirements as feature files with scenarios, outlines, and examples, along with step definition code to execute the tests.
The document provides 10 pieces of advice for software architects. It begins by introducing Eberhard Wolff and his background. Some of the key advice includes: understanding that the role of architect has changed with agile development and they are not managers; focusing on non-functional requirements and quality; caring about architecture and code quality rather than just diagrams; measuring code quality using tools; and ensuring proper dependency management to maintain architecture. The architect role is compared to that of a craftsman focusing on continual improvement rather than being separated from developers.
Expose Yourself! How to Leverage Plugin Extensibility to Delight your Users, ...Atlassian
The document discusses how developing plugins for Atlassian products can leverage extensibility to benefit users. It encourages plugin developers to expose APIs and build integrations between plugins to provide additional functionality. The talk will cover examples of integrations GreenHopper has built, best practices for developing APIs, and techniques for building integrations that play nicely with the plugin system while maintaining backwards compatibility.
The document is a 17 page presentation on the Adapter pattern. It defines the Adapter pattern as changing the interface of an existing class into another interface that is expected by clients. It discusses the intent, structure, applicability, consequences, known uses, and related patterns of the Adapter pattern. It also provides examples of its use and references for further information.
This document discusses SOLID principles, dependency inversion, dependency injection, and AutoMapper. It covers the benefits of loose coupling code using dependency injection such as improved testability and separation of concerns, as well as potential downsides like increased complexity. It provides examples of dependency injection frameworks like Unity and Ninject and demonstrates how AutoMapper can simplify mapping between objects.
DSL, Page Object and WebDriver – the path to reliable functional tests.pptxMikalai Alimenkou
Presentation from 10th SQADays conference in Moscow (December 2011) about different test design approaches to make functional tests on WebDriver more flexible, reliable and stable.
Concurrency is the ability to run several programs or several parts of a program in parallel. If a time consuming task can be performed asynchronously or in parallel, this improve the throughput and the interactivity of the program.
Developing for Remote Bamboo Agents, AtlasCamp US 2012Atlassian
Brydie McCoy, Java Developer
As more and more peoples' building demands grow, they expand from building everything locally to a distributed building system or the elastic cloud. And for OnDemand the elastic cloud is the only option. Unfortunately developing plugins for remote/elastic agents has its own set of gotchas. Most plugins written for Bamboo do not work properly on remote agents. This talk will cover the core principles of developing for remote agents, what you can and can't do, as well as more advanced topics such as data transfer and communication between the agent and the server.
CDI Best Practices with Real-Life Examples - TUT3287Ahmad Gohar
As the adoption of Contexts and Dependency Injection (CDI) for Java EE API grows, it is important to understand how to use CDI effectively to maximize the benefits of using a loosely coupled, type-safe, annotation-driven dependency injection solution. This session outlines the best practices for using CDI, such as annotations versus XML, @Named as a qualifier, qualifier type safety versus verbosity, effective use of producers/disposers, using scopes properly, best practices for using conversations, defining effective stereotypes, interceptors versus decorators, static versus dynamic injection/lookup, CDI versus Java EE resource injection, using CDI with EJB 3.1, CDI/JSF 2 integration patterns, and CDI/JPA 2 usage patterns.
This document provides an overview of test automation using Selenium. It discusses reasons to automate testing such as supporting regression testing and finding defects missed by manual testing. It also discusses when not to automate, such as when an application's behavior is unstable. The document then covers the Selenium framework, its components like Selenium IDE and WebDriver, and languages it supports like Java. It also discusses concepts in object-oriented programming relevant to test automation like classes, objects, inheritance and more.
Amir Barylko gave a presentation on easy automation for everyday projects at the Winnipeg Code Camp in February 2011. He discussed setting up automated builds, tests, dependencies and continuous integration for .NET projects using tools like Rake, Albacore, Bundler, Gallio and TeamCity. The presentation provided guidance on project structure, build scripts, unit testing, static analysis, deployment and acceptance testing.
Design patterns are not only cool but represent the collective wisdom of many developers. Since the publication of Design Patterns: Elements of Reusable Object-Oriented Software by GoF many new concepts have extended the coverage of these design patterns, and now Java EE provide out of the box implementations of many of the most well known patterns. This talk will show how, by taking advantage of Java EE features such as CDI and the smart use of annotations, traditional design patterns can be implemented in a much cleaner and quicker way. Among the design patterns discuss there will be Singleton, Façade, Observer, Factory, Dependency Injection, Decorator and more.
The document discusses Java EE 6 and its goals of being flexible, lightweight, and easier to develop on compared to previous versions. It outlines many of the new and updated specifications in Java EE 6, including Contexts and Dependency Injection, Bean Validation, JAX-RS, and others. It also describes key Java EE 6 concepts like managed beans, interceptors, and profiles aimed at improving ease of development.
Improving the Design of Existing SoftwareSteven Smith
The document discusses improving the design of existing software by following principles like DRY, SOLID, and refactoring code using techniques such as extracting classes, methods, and interfaces. It emphasizes writing characterization tests to preserve existing behavior when refactoring, and improving code quality by reducing duplication, dependencies, and complexity over time through preventative maintenance and refactoring.
Originally this was proposed as "88 Slides About 44 Modules" but it was scaled back to "44 Slides About 22 Modules". It was meant as a quick and dirty introduction to small niche / utility modules that people may not have been aware of (with a couple hardcore useful dev modules mixed in.)
Introducing domain driven design - dogfood con 2018Steven Smith
DDD provides a set of patterns and practices for tackling complex business problems with software models. Learn the basics of DDD in this session, including several principles and patterns you can start using immediately even if your project hasn't otherwise embraced DDD. Examples will primarily use C#/.NET.
This document discusses JRebel, a tool that allows developers to see code changes in web applications without redeploying. It summarizes JRebel's key features, licensing options, and how it works by redefining classes at runtime using instrumentation and bytecode handling to allow reloading updated classes. It then demonstrates how JRebel can be used with GateIn to achieve zero-redeployment of portlets and UI components.
Design Pattern Mastery - Momentum Dev Con 19 Apr 2018Steven Smith
Design patterns help developers and teams solve problems using proven approaches. In this talk, you'll learn how to solve a series of real world problems by applying patterns. Not only do patterns help individual developers solve particular problems, but they also enable teams to discuss design decisions using a richer, more descriptive language. By the end, you'll have some concrete tools you can apply, and hopefully the desire to master more patterns as you continue to improve!
"Architecting and testing large iOS apps: lessons from Facebook". Adam Ernst,...Yandex
In 2012 Facebook relaunched their iOS app to use native code. This was a big shift in architecting and implementing the Facebook app experience, the most widely used third party app on the entire iOS platform. Adam Ernst will speak about how the decision was made to switch to native code and how the company prepared to rewrite the app. He will share an inside look at the APIs and technical architecture Facebook uses to enable dozens of iOS developers to work on the same application. Automated testing is very important to Facebook, so Adam will also speak about how Facebook uses testing on iOS to keep the app reliable.
Do we need SOLID principles during software development?Anna Shymchenko
The document discusses the SOLID principles of object-oriented design. It defines each principle - Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. It also addresses common project design issues SOLID principles can help solve like instability, immobility, and complexity. Both benefits and potential disadvantages of SOLID like an overuse of abstractions or small modules are presented.
The document discusses executable requirements and behavior-driven development (BDD). It defines what makes a good requirement and gives examples of use cases, user stories, and traceability matrices. The presentation argues that executable requirements in BDD tools like SpecFlow help ensure requirements are testable and prevent issues like missed requirements or developer misinterpretation. It demonstrates writing executable requirements as feature files with scenarios, outlines, and examples, along with step definition code to execute the tests.
The document provides 10 pieces of advice for software architects. It begins by introducing Eberhard Wolff and his background. Some of the key advice includes: understanding that the role of architect has changed with agile development and they are not managers; focusing on non-functional requirements and quality; caring about architecture and code quality rather than just diagrams; measuring code quality using tools; and ensuring proper dependency management to maintain architecture. The architect role is compared to that of a craftsman focusing on continual improvement rather than being separated from developers.
Expose Yourself! How to Leverage Plugin Extensibility to Delight your Users, ...Atlassian
The document discusses how developing plugins for Atlassian products can leverage extensibility to benefit users. It encourages plugin developers to expose APIs and build integrations between plugins to provide additional functionality. The talk will cover examples of integrations GreenHopper has built, best practices for developing APIs, and techniques for building integrations that play nicely with the plugin system while maintaining backwards compatibility.
The document is a 17 page presentation on the Adapter pattern. It defines the Adapter pattern as changing the interface of an existing class into another interface that is expected by clients. It discusses the intent, structure, applicability, consequences, known uses, and related patterns of the Adapter pattern. It also provides examples of its use and references for further information.
This document discusses SOLID principles, dependency inversion, dependency injection, and AutoMapper. It covers the benefits of loose coupling code using dependency injection such as improved testability and separation of concerns, as well as potential downsides like increased complexity. It provides examples of dependency injection frameworks like Unity and Ninject and demonstrates how AutoMapper can simplify mapping between objects.
DSL, Page Object and WebDriver – the path to reliable functional tests.pptxMikalai Alimenkou
Presentation from 10th SQADays conference in Moscow (December 2011) about different test design approaches to make functional tests on WebDriver more flexible, reliable and stable.
Concurrency is the ability to run several programs or several parts of a program in parallel. If a time consuming task can be performed asynchronously or in parallel, this improve the throughput and the interactivity of the program.
Developing for Remote Bamboo Agents, AtlasCamp US 2012Atlassian
Brydie McCoy, Java Developer
As more and more peoples' building demands grow, they expand from building everything locally to a distributed building system or the elastic cloud. And for OnDemand the elastic cloud is the only option. Unfortunately developing plugins for remote/elastic agents has its own set of gotchas. Most plugins written for Bamboo do not work properly on remote agents. This talk will cover the core principles of developing for remote agents, what you can and can't do, as well as more advanced topics such as data transfer and communication between the agent and the server.
CDI Best Practices with Real-Life Examples - TUT3287Ahmad Gohar
As the adoption of Contexts and Dependency Injection (CDI) for Java EE API grows, it is important to understand how to use CDI effectively to maximize the benefits of using a loosely coupled, type-safe, annotation-driven dependency injection solution. This session outlines the best practices for using CDI, such as annotations versus XML, @Named as a qualifier, qualifier type safety versus verbosity, effective use of producers/disposers, using scopes properly, best practices for using conversations, defining effective stereotypes, interceptors versus decorators, static versus dynamic injection/lookup, CDI versus Java EE resource injection, using CDI with EJB 3.1, CDI/JSF 2 integration patterns, and CDI/JPA 2 usage patterns.
This document provides an overview of test automation using Selenium. It discusses reasons to automate testing such as supporting regression testing and finding defects missed by manual testing. It also discusses when not to automate, such as when an application's behavior is unstable. The document then covers the Selenium framework, its components like Selenium IDE and WebDriver, and languages it supports like Java. It also discusses concepts in object-oriented programming relevant to test automation like classes, objects, inheritance and more.
Amir Barylko gave a presentation on easy automation for everyday projects at the Winnipeg Code Camp in February 2011. He discussed setting up automated builds, tests, dependencies and continuous integration for .NET projects using tools like Rake, Albacore, Bundler, Gallio and TeamCity. The presentation provided guidance on project structure, build scripts, unit testing, static analysis, deployment and acceptance testing.
Design patterns are not only cool but represent the collective wisdom of many developers. Since the publication of Design Patterns: Elements of Reusable Object-Oriented Software by GoF many new concepts have extended the coverage of these design patterns, and now Java EE provide out of the box implementations of many of the most well known patterns. This talk will show how, by taking advantage of Java EE features such as CDI and the smart use of annotations, traditional design patterns can be implemented in a much cleaner and quicker way. Among the design patterns discuss there will be Singleton, Façade, Observer, Factory, Dependency Injection, Decorator and more.
The document discusses Java EE 6 and its goals of being flexible, lightweight, and easier to develop on compared to previous versions. It outlines many of the new and updated specifications in Java EE 6, including Contexts and Dependency Injection, Bean Validation, JAX-RS, and others. It also describes key Java EE 6 concepts like managed beans, interceptors, and profiles aimed at improving ease of development.
This session compares the Spring and Java EE stacks in terms of Web frameworks. It re-examines the motivations behind the Spring framework and explores the emergence of the Java EE programming model to meet the challenges posed. The presentation provides insight into when Spring and/or Java EE is appropriate for a building Web applications and if they can coexist.
This document summarizes several design patterns used in Java EE, including Singleton, Abstract Factory, Facade, Decorator, Observer, MVC, and Domain Driven Design. It provides examples of how each pattern can be implemented in Java EE using annotations like @Singleton, @Produces, @Stateless, @Inject, and more. It also briefly discusses the pros and cons of implementing these patterns in Java EE.
SE2016 IoT Maksym Antipov "Hardware development as a hobby and a job"Inhacking
Event: #SE2016
Stage: IoT & BigData
Data: 2 of September 2016
Speaker: Maksym Antipov
Topic: Hardware development as a hobby and a job
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
The primary reason behind development of Java was to bring mobility and protection function into a computer terminology. Beside these two major functions, there were many other functions that performed an part in moulding out the ultimate form of this excellent terminology. Those functions are :
Dokumen ini membandingkan model gravitasi Hansen dan model potensi lahan dalam memprediksi pertambahan penduduk di 4 kecamatan Kota Lubuklinggau antara tahun 2010-2015. Model gravitasi Hansen mempertimbangkan jarak dan daya tarik antar kecamatan, sedangkan model potensi lahan juga mempertimbangkan luas lahan kosong dan fasilitas. Kedua model menyimpulkan bahwa kecamatan Lubuklinggau Timur akan mengalami pertambahan penduduk ter
Design patterns are not only cool but represent the collective wisdom of many developers. Since the publication of Design Patterns: Elements of Reusable Object-Oriented Software by GoF many new concepts have extended the coverage of these design patterns, and now Java EE provides out-of-the box implementations of many of the most well known patterns. This talk will show how, by taking advantage of Java EE features such as CDI and the smart use of annotations, traditional design patterns can be implemented in a much cleaner and quicker way. Among the design patterns discuss there will be Singleton, Façade, Observer, Factory, Dependency Injection, Decorator and more.
SE2016 - Java EE revisits design patterns 2016Alex Theedom
Design patterns are not only cool but represent the collective wisdom of many developers. Since the publication of Design Patterns: Elements of Reusable Object-Oriented Software by GoF many new concepts have extended the coverage of these design patterns, and now Java EE provides out-of-the box implementations of many of the most well known patterns. This talk will show how, by taking advantage of Java EE features such as CDI and the smart use of annotations, traditional design patterns can be implemented in a much cleaner and quicker way. Among the design patterns discuss there will be Singleton, Façade, Observer, Factory, Dependency Injection, Decorator and more.
Design patterns are not only cool but represent the collective wisdom of many developers. Since the publication of Design Patterns: Elements of Reusable Object-Oriented Software by GoF many new concepts have extended the coverage of these design patterns, and now Java EE provide out of the box implementations of many of the most well known patterns. This talk will show how, by taking advantage of Java EE features such as CDI and the smart use of annotations, traditional design patterns can be implemented in a much cleaner and quicker way. Among the design patterns discuss there will be Singleton, Façade, Observer, Factory, Dependency Injection, Decorator and more.
Java EE changes design pattern implementation: JavaDays Kiev 2015Alex Theedom
The implementation of traditional design patterns have changed in Java EE 7. By taking advantage of Java EE features such as CDI and the smart use of annotations, traditional design patterns can be implemented in a much cleaner and quicker way. With the use of code examples I will demonstrate how to implement some of the most commonly use design patterns in Java EE. Among the design patterns discuss there will be Factory, Singleton, Observer and Decorator.
Design Patterns are not only cool but also bring years of collective wisdom to every level of developers. Since GoF, many books have been written and words shed, as well as many new concepts like Enterprise and Domain Design Patterns extended the coverage the Design Patterns, originally shared by the famous Gang of Four. Unlike the J2EE 1.4 era, Java EE provides easy and out of box implementations of many well known design patterns such as Singleton, Façade, Observer, Factory, Dependency Injection, Decorator, Data Access Patterns, MVC and even more. Many classical design patterns are actually just one annotation away from your project.
Sitecore development approach evolution – destination helixPeter Nazarov
Sitecore Development Approach Evolution – Destination Helix
Sitecore officially recommended Helix as a set of overall design principles and conventions for Sitecore development around 18 month ago at SUGCON 2016 alongside with an official implementation example - Habitat. Why was it necessary? What are the benefits? Has it worked in practice? Peter Nazarov will share the outlook on why and how a combination of Sitecore Helix and Habitat benefits the business and development users of Sitecore in practice.
My sldies from a talk including an intro to features, exportables, issues with features, state of features and how to implmenet the exportable and feature API
This document discusses design patterns and principles. It begins by defining design patterns as repeatable solutions to common design problems. It then covers several design patterns including Singleton, Strategy, Adapter, Template, Factory, Abstract Factory, and Observer patterns. It also discusses low-level principles like Tell Don't Ask and high-level principles like the Single Responsibility Principle. Finally, it provides examples of how to implement some of the patterns and principles in code.
This presentation will be useful to those
who would like to get acquainted with lifetime history
of successful monolithic Java application.
It shows architectural and technical evolution of one Java web startup that is beyond daily coding routine and contains a lot of simplifications, Captain Obvious and internet memes.
But this presentation is not intended for monolithic vs. micro services architectures comparison.
This document discusses component-first applications and provides an overview of components. It begins with an agenda and introductions. It then defines what a component is, explains why to use components, and compares components to MVC. It provides dos and don'ts of components and examples. Finally, it discusses using a pub/sub pattern with components.
Angular 2 is a new version of AngularJS that is currently in alpha. It embraces modern web standards like Shadow DOM and Web Workers. Angular 2 components replace directives and use classes instead of controllers. Templates are now called views. Two-way binding and ng-repeat are changed. The API is still changing but you can try it now on angular.io.
This document provides an overview of new features in Visual Studio 11 including:
- Graphical design tools built into PowerPoint for creating user interfaces
- Ability to capture screenshots, animations, and share templates
- Backlog management tool for prioritizing product owner work
- Context switching that allows saving and restoring a developer's entire environment
- Code reviews and unit testing integrated directly into the IDE
- Intellitrace for debugging production issues by capturing events and calls
- Integration with Microsoft System Center and Team Foundation Server
This document discusses code generation in .NET. It begins by outlining some common problems developers face when dealing with large amounts of repetitive code. It then discusses various approaches to solving this problem, including hand coding everything, fully generic design, and using a combination of tools including code generation. The rest of the document discusses specific code generation tools for .NET like StringBuilder, CodeSnippets, XSLT, Reflection.Emit, EnvDTE, CodeDom, and T4. It also discusses pros and cons of each approach and provides examples of using code generation in different real world scenarios.
Stencil the time for vanilla web components has arrivedGil Fink
Stencil provides a compiler that generates standard-compliant custom elements from components written using its API, making it easier to create reusable web components. It addresses problems with vanilla custom elements by adding features like virtual DOM, reactivity, JSX and TypeScript support. Stencil components can be used by any framework since the output is just standard web components, avoiding issues of framework coupling. It also helps create sharable infrastructure components and enables building microfrontends with shared behaviors across applications.
Using BladeRunnerJS to Build Front-End Apps that Scale - Fluent 2014Phil Leggetter
Developing large apps is difficult. Ensuring that code is consistent, well structured, tested and has an architecture that encourages enhancement and maintainability is essential. When it comes to building large server-focused apps the solutions to this problem have been tried and tested. But, how do you achieve this when building HTML5 single page apps?
BladeRunnerJS is an open source developer toolkit and lightweight front-end framework that has helped Caplin Systems ensure that a 200k LoC JavaScript codebase hasn’t become a tangled mess of unstable spaghetti code. This codebase is packaged and delivered to customers as an SDK. Additionally customers receive a getting started application of around 50k LoC for them to build upon, and they’re expected not to turn that into a tangled … you get the idea.
In this talk you’ll learn the main concepts to apply when building a front-end app that scales and how BladeRunnerJS can support the development process.
Devconf 2011 - PHP - How Yii framework is developedAlexander Makarov
This document discusses the development of the Yii PHP framework. It was originally developed from Prado in 2004 and became Yii 1.0 in 2008. The framework uses an MVC architecture and takes inspiration from other frameworks like Rails and Symfony. It focuses on being easy to use, powerful, and flexible. The framework is developed as an open source project under the BSD license to encourage contributions from the community.
Attain Clean Code in Sitecore Solutions using Design PatternsMichael Reynolds
The document discusses design patterns and how they can be used to attain clean code in Sitecore solutions. It defines what design patterns are, provides a brief history of their development, and gives examples of common patterns like Adapter, Decorator, Composite, and Chain-of-Responsibility. The presentation encourages learning more about design patterns through recommended books and blog posts, and provides contact information for the presenter.
Improving the Quality of Existing SoftwareSteven Smith
The document discusses techniques for improving the quality of existing software, including reducing technical debt, following principles like DRY and SOLID, using characterization tests to preserve behavior during refactoring, and improving skills to write higher quality code faster. It covers topics like refactoring, test-driven development, dependency inversion, and design patterns. The goal is to maintain and enhance application code quality over time through refactoring and preventing technical debt.
Similar to SE2016 Java Alex Theedom "Java EE revisits design patterns" (20)
SE2016 Company Development Valentin Dombrovsky "Travel startups challenges an...Inhacking
Event: #SE2016
Stage: Company Development
Data: 3 of September 2016
Speaker: Valentin Dombrovsky
Topic: Travel startups challenges and opportunities
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Company Development Vadym Gorenko "How to pass the death valley"Inhacking
Event: #SE2016
Stage: Company Development
Data: 3 of September 2016
Speaker: Jan Keil
Topic: Do the right thing marketing for startups
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Marketing&PR Jan Keil "Do the right thing marketing for startups"Inhacking
Event: #SE2016
Stage: Marketing&PR
Data: 3 of September 2016
Speaker: Jan Keil
Topic: Do the right thing marketing for startups
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 PR&Marketing Mikhail Patalakha "ASO how to start and how to finish"Inhacking
Event: #SE2016
Stage: PR&Marketing
Data: 2 of September 2016
Speaker: Mikhail Patalaha
Topic: ASO how to start and how to finish
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 UI/UX Alina Kononenko "Designing for Apple Watch and Apple TV"Inhacking
Event: #SE2016
Stage: UI/UX
Data: 2 of September 2016
Speaker: Alina Kononenko
Topic: Designing for Apple Watch and Apple TV
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Management Mikhail Lebedinkiy "iAIST the first pure ukrainian corporat...Inhacking
Event: #SE2016
Stage: Management & Trends
Data: 2 of September 2016
Speaker: Mikhail Lebedinkiy
Topic: iAIST the first pure Ukrainian corporate ERP and BI cloud service
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Management Anna Lavrova "Gladiator in the suit crisis is our brand!"Inhacking
Event: #SE2016
Stage: Management & Trends
Data: 2 of September 2016
Speaker: Anna Lavrova
Topic: Gladiator in the suit crisis is our brand!
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Management Aleksey Solntsev "Management of the projects in the conditi...Inhacking
Event: #SE2016
Stage: Management & Trends
Data: 2 of September 2016
Speaker: Aleksey Solntsev
Topic: Management of the projects in the conditions of uncertainty
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Management Vitalii Laptenok "Processes and planning for a product comp...Inhacking
Event: #SE2016
Stage: Management & Trends
Data: 2 of September 2016
Speaker: Vitalii Laptenok
Topic: Processes and planning for a product company
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 iOS Anton Fedorchenko "Swift for Server-side Development"Inhacking
Event: #SE2016
Stage: iOS
Data: 4 of September 2016
Speaker: Anton Fedorchenko
Topic: Swift for Server-side Development
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 iOS Alexander Voronov "Test driven development in real world"Inhacking
Event: #SE2016
Stage: iOS
Data: 4 of September 2016
Speaker: Alexander Voronov
Topic: Test Driven Development in real world
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 JS Gregory Shehet "Undefined on prod, or how to test a react application"Inhacking
Event: #SE2016
Stage: JS
Data: 4 of September 2016
Speaker: Gregory Shehet
Topic: Undefined on prod, or how to test a react application
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
SE2016 Java Vladimir Mikhel "Scrapping the web"Inhacking
Event: #SE2016
Stage: Java
Data: 3 of September 2016
Speaker: Vladimir Mikhel
Topic: Scrapping the web
INHACKING site: https://inhacking.com
SE2016 site: http://se2016.inhacking.com/
This document provides an overview and agenda for an Apache HBase workshop. It introduces HBase as an open-source NoSQL database built on Hadoop that uses a column-family data model. The agenda covers what HBase is, its data model including rows, columns, cells and versions, CRUD operations, architecture including regions and masters, schema design best practices, and the Java API. Performance tips are given for client reads and writes such as using batches, caching, and tuning durability.
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
DDS Security Version 1.2 was adopted in 2024. This revision strengthens support for long runnings systems adding new cryptographic algorithms, certificate revocation, and hardness against DoS attacks.
Utilocate offers a comprehensive solution for locate ticket management by automating and streamlining the entire process. By integrating with Geospatial Information Systems (GIS), it provides accurate mapping and visualization of utility locations, enhancing decision-making and reducing the risk of errors. The system's advanced data analytics tools help identify trends, predict potential issues, and optimize resource allocation, making the locate ticket management process smarter and more efficient. Additionally, automated ticket management ensures consistency and reduces human error, while real-time notifications keep all relevant personnel informed and ready to respond promptly.
The system's ability to streamline workflows and automate ticket routing significantly reduces the time taken to process each ticket, making the process faster and more efficient. Mobile access allows field technicians to update ticket information on the go, ensuring that the latest information is always available and accelerating the locate process. Overall, Utilocate not only enhances the efficiency and accuracy of locate ticket management but also improves safety by minimizing the risk of utility damage through precise and timely locates.
A Study of Variable-Role-based Feature Enrichment in Neural Models of CodeAftab Hussain
Understanding variable roles in code has been found to be helpful by students
in learning programming -- could variable roles help deep neural models in
performing coding tasks? We do an exploratory study.
- These are slides of the talk given at InteNSE'23: The 1st International Workshop on Interpretability and Robustness in Neural Software Engineering, co-located with the 45th International Conference on Software Engineering, ICSE 2023, Melbourne Australia
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Looking for a reliable mobile app development company in Noida? Look no further than Drona Infotech. We specialize in creating customized apps for your business needs.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
When deliberating between CodeIgniter vs CakePHP for web development, consider their respective strengths and your project requirements. CodeIgniter, known for its simplicity and speed, offers a lightweight framework ideal for rapid development of small to medium-sized projects. It's praised for its straightforward configuration and extensive documentation, making it beginner-friendly. Conversely, CakePHP provides a more structured approach with built-in features like scaffolding, authentication, and ORM. It suits larger projects requiring robust security and scalability. Ultimately, the choice hinges on your project's scale, complexity, and your team's familiarity with the frameworks.
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.
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.
Takashi Kobayashi and Hironori Washizaki, "SWEBOK Guide and Future of SE Education," First International Symposium on the Future of Software Engineering (FUSE), June 3-6, 2024, Okinawa, Japan
OpenMetadata Community Meeting - 5th June 2024OpenMetadata
The OpenMetadata Community Meeting was held on June 5th, 2024. In this meeting, we discussed about the data quality capabilities that are integrated with the Incident Manager, providing a complete solution to handle your data observability needs. Watch the end-to-end demo of the data quality features.
* How to run your own data quality framework
* What is the performance impact of running data quality frameworks
* How to run the test cases in your own ETL pipelines
* How the Incident Manager is integrated
* Get notified with alerts when test cases fail
Watch the meeting recording here - https://www.youtube.com/watch?v=UbNOje0kf6E
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
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!
AI Fusion Buddy Review: Brand New, Groundbreaking Gemini-Powered AI AppGoogle
AI Fusion Buddy Review: Brand New, Groundbreaking Gemini-Powered AI App
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-fusion-buddy-review
AI Fusion Buddy Review: Key Features
✅Create Stunning AI App Suite Fully Powered By Google's Latest AI technology, Gemini
✅Use Gemini to Build high-converting Converting Sales Video Scripts, ad copies, Trending Articles, blogs, etc.100% unique!
✅Create Ultra-HD graphics with a single keyword or phrase that commands 10x eyeballs!
✅Fully automated AI articles bulk generation!
✅Auto-post or schedule stunning AI content across all your accounts at once—WordPress, Facebook, LinkedIn, Blogger, and more.
✅With one keyword or URL, generate complete websites, landing pages, and more…
✅Automatically create & sell AI content, graphics, websites, landing pages, & all that gets you paid non-stop 24*7.
✅Pre-built High-Converting 100+ website Templates and 2000+ graphic templates logos, banners, and thumbnail images in Trending Niches.
✅Say goodbye to wasting time logging into multiple Chat GPT & AI Apps once & for all!
✅Save over $5000 per year and kick out dependency on third parties completely!
✅Brand New App: Not available anywhere else!
✅ Beginner-friendly!
✅ZERO upfront cost or any extra expenses
✅Risk-Free: 30-Day Money-Back Guarantee!
✅Commercial License included!
See My Other Reviews Article:
(1) AI Genie Review: https://sumonreview.com/ai-genie-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
#AIFusionBuddyReview,
#AIFusionBuddyFeatures,
#AIFusionBuddyPricing,
#AIFusionBuddyProsandCons,
#AIFusionBuddyTutorial,
#AIFusionBuddyUserExperience
#AIFusionBuddyforBeginners,
#AIFusionBuddyBenefits,
#AIFusionBuddyComparison,
#AIFusionBuddyInstallation,
#AIFusionBuddyRefundPolicy,
#AIFusionBuddyDemo,
#AIFusionBuddyMaintenanceFees,
#AIFusionBuddyNewbieFriendly,
#WhatIsAIFusionBuddy?,
#HowDoesAIFusionBuddyWorks
4. What’s on?
• Design patterns retrospective
• Map classical design patterns to Java EE 7
• Contexts and Dependency Injection
• Singleton, Factory, Façade, Decorator and Observer
• Final Conclusions
• Q&A
5. What are you doing?
• Java Enterprise Edition (J2EE, EE 6/7)
• Spring
6. The beginning
•Design Patterns: Elements of Reusable Object-Oriented Software
(E Gamma, R Helm, R Johnson and J Vlissides. 1994)
AKA Gang of Four AKA GoF
•Creational, behavioral and structural
•So what are design patterns in practice?
7. Enterprise Java and design patterns
•JavaOne 2000 talk: Prototyping patterns for the J2EE
platform
•Core J2EE Patterns (D. Anur, J. Crupi and D. Malks)
•Out-of-box design pattern implementations with
Java EE 5
8. Java EE Programming Model
•Simplified programming model
• Annotations have replaced XML description files
• Convention over Configuration
• CDI hides object creation
•Resources are injected by type
9. Singleton Pattern
•Creational pattern
•Single instance and instantiated once
•Must be thread safe
•Not normally destroy during application life cycle
•Classic implementation: private constructor, double
locking, static initializer, enums …
11. Singleton Pattern
•Conclusions so far
• Very different implementation
• Substantially less boilerplate code
• Enhancements via specialized annotations
There’s more…
13. The Good, Bad and the Ugly
•The Good:
•enhancements via specialized annotations
•startup behavioural characteristics
•fine grain control over concurrency and access
timeout
•substantially less boilerplate code
14. The Good, Bad and the Ugly
•The Bad:
•overuse can cause problems
•lazy loading causes delays
•eager loading causes memory problems
15. •And the ugly:
•considered an anti-pattern
•only niche use
•smarter to use a stateless session bean
The Good, Bad and the Ugly
17. Factory Pattern
•CDI framework is a factory !?!
public class CoffeeMachine implements DrinksMachine {
// Implementation code
}
•Use it like so:
@Inject
DrinksMachine drinksMachine;
18. Factory Pattern
•Problem! Multiple concrete implementations
public class CoffeeMachine implements DrinksMachine {
// Implementation code
}
public class SoftDrinksMachine implements DrinksMachine {
// Implementation code
}
@Inject
DrinksMachine drinksMachine;
•Which DrinksMachine to inject?
?!?
22. Factory Pattern
•Remember
•Only JSR299 beans are ‘injectable’
•But I want to inject a Collection type or Object with a
parameterized constructor
-> let’s dive deeper
23. Factory Pattern
•Dive deeper
• Producer methods
• Use it like so:
@History
@Produces
public List<Book> getLibrary(){
// Generate a List of books called 'library'
return library;
}
@History
@Inject
List<Books> library;
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface History
24. Factory Pattern
• Scope
• Determines when method called
• Life of object: @RequestScoped -> @ApplicationScoped
@RequestScoped
@History
@Produces
public List<Book> getLibrary(){
// Generate a List of books called 'library'
return library;
}
25. The Good, Bad and the Ugly
•The Good:
•easy to implement
•no boilerplate code
•works magically
•any object can be made injectable
26. The Good, Bad and the Ugly
•The Bad: named annotation is not type safe
@Named("History") -> @History
•and the ugly: object creation hidden, hard to follow
execution flow, IDE should help
27. Façade Pattern
•Hides the complex logic and provides the interface for
the client
•Typically used in APIs
•Classic implementation: Just create a method to hide
complexity
28. Façade Pattern
•Encapsulates complicated logic
• @Stateless, @Stateful@Stateless
public class BankServiceFacade{
public void complexBusinessLogic(){
// Very very complex logic
}
}
@Inject
public BankServiceFacade service;
29. The Good, Bad and the Ugly
•The Good: simple, robust, gives you a range of services
•The Bad: over use introduces unnecessary layers, if you
don’t need it don’t introduce one
•and the ugly: there isn’t one really
30. Decorator Pattern
•Structural Pattern
•Dynamically adds logic to an object at runtime
•More flexible that inheritance
•Classic implementation: Both the decorator and target
object share the same interface. Decorator wraps the
target object and adds its own behaviour
32. •The Good: very easy to change behaviour without
breaking legacy code
•The Bad: needs XML config (<CDI 1.1)
•and the ugly: overuse will introduce an execution flow
which is hard to follow
The Good, Bad and the Ugly
34. Observer Pattern
•Define an event class
public class MessageEvent {
private String message;
public MessageEvent(String message){
this.message = message;
}
public String getMessage(){
return message;
}
}
35. Observer Pattern
•Notifies dependents of state change
@Stateless
public class MessageService {
@Inject
Event<MessageEvent> messageEvent;
public void fireMessage(){
messageEvent.fire(new MessageEvent("Hello World"));
}
}
36. Observer Pattern
•Dependent receives state change notification
@Stateless
public class MessageObserver {
public void listenToMessage(@Observes MessageEvent message){
System.out.println(message.getMessage());
}
}
37. Observer Pattern
•Qualifier to filter events
@WarningMessage
@Inject
Event<MessageEvent> messageEvent;
public void listenToMessage(
@Observes @WarningMessage MessageEvent message)
38. The Good, Bad and the Ugly
•The Good: very easy, no boilerplate code, less than JMS,
the container does the heavy lifting, light weight
•The Bad: confusing execution order but IDE will help
•and the ugly: nothing, its beautiful
39. Entity
•Lightweight domain object which is persistable
•Annotated with javax.persistence.Entity
•Can represent relational data object/relational mapping
annotations
40. Entity
@Entity
public class Contact {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String firstName;
private String lastName;
}