Hidden rocks in Oracle ADF

The document discusses issues with testing business logic in Orleans grains that access grain state. Specifically, the business logic code is duplicated across grain methods and calling the logic directly in tests fails because the grain state is null. The solution is to use Orleans' declarative persistence by defining a grain state interface and inheriting from Grain, which allows the state to be initialized for tests.

This document discusses using Jasmine to test JavaScript code. It describes Jasmine as a behavior driven development framework for JavaScript testing. It then provides instructions on installing Jasmine, creating spec files to contain test cases, and including source code files. The document uses an example of testing a master-slave checkbox relationship to demonstrate how to set up tests, DOM elements, and code the tests against the actual code implementation.

The document provides an overview of JavaScript, including that it is used to make web pages interactive, runs in browsers, and supports built-in. It discusses the DOM, common events, using the console, variables, operators, comments, conditionals, loops, arrays, objects, type checking, functions, events, timers, accessing and manipulating DOM elements, working with CSS/classes, and AJAX requests.

This document provides an introduction to jQuery, including examples of how to use jQuery. It discusses jQuery plugins, performance tips for jQuery, and jQuery deferreds/promises. Some key points: - jQuery is a JavaScript library that allows DOM manipulation and event handling via JavaScript - jQuery code uses $ as an alias for jQuery functions - Plugins can extend jQuery's functionality - For performance, cache selections, append outside loops, detach/reattach elements being modified - Deferreds/promises allow asynchronous functions to be chained together

Workshop JavaScript Testing. Frameworks. Client vs Server Testing. Jasmine. Chai. Nock. Sinon. Spec Runners: Karma. TDD. Code coverage. Building a testable JS app. Presentado por ing: Raúl Delgado y Mario García

Building complex async applications is really hard. Whether you use callbacks, Promises, or EventEmitters, Error objects should have a place in your utility belt. They are indispensable when it comes to managing work flows in a highly asynchronous environment. This talk covers patterns for using JavaScript Error (with a capital E) objects to build resilient applications, and introduce some modules that can be used to build errors with an elegant history of stack traces even through multiple asynchronous operations. Try/catch, callbacks, and other error handling mechanisms will be examined, revealing some potential deficiencies in the JavaScript language for dealing with errors. Video: https://www.youtube.com/watch?v=PyCHbi_EqPs

This document discusses JavaScript unit testing with Jasmine. It provides an overview of Jasmine's syntax including describes, contexts, matches, spies and stubs. It also discusses tools that can be used with Jasmine like jasmine-jquery for DOM testing and jasmine-given for behavior-driven development style tests.

The document discusses a tool called HATARI that helps identify risky locations in code based on past fix-inducing changes. HATARI calculates a risk score for each location based on the number of past fix-inducing changes compared to the total number of changes. It visualizes risk scores with annotations to show developers potentially risky areas. HATARI will be made open source on November 1st and is available at http://www.st.cs.uni-sb.de/softevo/.

How do you create applications with an incredible level of extendability without losing readability in the process? What if there's a way to separate concerns not only on the code, but on the service definition level? This talk will explore structural and behavioural patterns and ways to enrich them through tricks of powerful dependency injection containers such as Symfony2 DIC component.

This is the support of a course to teach mainly Redux, and Redux with React for Java and C# programmers. It is the third part of the course to recycle programmers from desktop app programming to web app programming. This course covers from history of Redux, its origin, step by step what is a reducer, and later concepts like reducer splitting, action handling, async and many more. You also can use repositories: - https://github.com/drpicox/learn-redux-bytesting - https://github.com/drpicox/learn-redux-zoo-bytesting To improve your skills.

Presentation i gave at londonweb august on building a site on what turned out to be 12 preview, 5 beta, 6 RC and a final release of Symfony 2.

A lot of people using PHPunit for testing their source code. While I was observing my team I recognized most of them are only using the standard assertions like 'assertEquals()' and are complaining about how hard it is to test the code even when the tests are written first. This talk is about all the stuff not used on a daily basis and it digs deep into uncommon features of PHPUnit.

The document appears to be notes on Backbone.js. It includes summaries of Backbone models, events, views and how to bind events. It demonstrates creating a model with defaults, getting/setting attributes, and binding event handlers. It also shows creating a view with tagName, className and attributes, and logging the generated HTML element.

This document contains a summary of jQuery secrets presented by Bastian Feder. It discusses various techniques including saving and removing state from DOM elements using jQuery.data() and jQuery.removeData(), extending jQuery functionality through plugins, and customizing AJAX requests and event handling. The presentation provides code examples for working with jQuery's data storage methods, namespaces, promises/deferreds, global AJAX settings, and extending jQuery.

The document discusses refactoring legacy PHP code, specifically dealing with code that has no separation between PHP and HTML. It recommends separating code into controllers and views by gathering all code, separating controller and view code, assigning variables to a view object, changing variable references in the view code, and splitting the files. Specific problems in legacy PHP code like no separation of concerns, global variables, and reliance on includes can be addressed through techniques like creating view classes, encapsulating logic in objects, and wrapping includes in functions to untangle dependency webs. The goal is to safely change code implementation without changing behavior through refactoring.

The document discusses Ruby and Ruby on Rails. It notes that Ruby is an object-oriented programming language created by Yukihiro Matsumoto in 1995. Ruby on Rails is a web application framework built on Ruby that was created by David Heinemeier Hansson in 2004. It follows the model-view-controller architectural pattern, separating applications into models, views, and controllers.

- Ruby is an interactive, object-oriented programming language created by Yukihiro Matsumoto in 1995. - Ruby on Rails is a web application framework built on Ruby that emphasizes convention over configuration and is optimized for programmer happiness. - The document discusses Ruby and Ruby on Rails, providing an overview of their history, key principles like MVC, REST, and conventions used in Rails. It also provides examples of modeling data with classes and ActiveRecord in Rails.

Slides from Oracle's ADF Architecture TV series covering the Design phase of ADF projects, considering integrating PLSQL into your ADF applications. Like to know more? Check out: - Subscribe to the YouTube channel - http://bit.ly/adftvsub - Design Playlist - http://www.youtube.com/playlist?list=PLJz3HAsCPVaSemIjFk4lfokNynzp5Euet - Read the episode index on the ADF Architecture Square - http://bit.ly/adfarchsquare

Discover all of the latest statistics and trends in the malware industry. See the infographic here: http://anti-virus-software-review.toptenreviews.com/how-infected-are-we.html

This document provides an overview of the key components of Cloud Foundry, including: - The Cloud Controller which manages application deployments, services, user roles, and more. - Buildpacks which stage and compile applications to create droplets run by DEAs on VMs. - DEAs which manage application container lifecycles using Warden containers for isolation. - Routers which route traffic to applications and maintain dynamic routing tables. - Services which provide interfaces to both native and 3rd party services running on Service Nodes. - UAA which handles user authentication, authorization, and manages OAuth access credentials. It also describes how organizations and spaces segment the platform and how domains

Cloudfoundry is the open platform as a service providing a faster and easier way to build, test, deploy and scale applications.Deploy & Scale in seconds on your choice of clouds.

This presentation covers both the Cloud Foundry Elastic Runtime (known by many as just "Cloud Foundry") as well as the Operations Manager (known by many as BOSH). For each, the main components are covered with interactions between them.

JavaFX 8 est disponible depuis mars 2014 et apporte son lot de nouveautés. Gradle est en version 2 depuis juillet 2014. Deux technologies plus que prometteuses: JavaFX donne un coup de jeune au développement d’applications desktop en Java en apportant un navigateur web intégré, le support des WebSockets, de la 3D, et bien d’autres. Gradle est l’outil de d’automatisation de build à la mode, apportant de superbes possibilités par rapport rapport à maven, outil vieillissant, grâce à l’engouement de la communauté vis à vis de cet outil mais aussi par le fait de la technologie utilisée en son sein: groovy. Venez découvrir comment il est possible de réaliser rapidement une application à la mode en JavaFX avec un outil à la mode également. Bref venez à une session trendy.

Some examples of using Reflections and automatic code generation to reduce the amount of code developers have to write.

Rewrite few familiar Cocoa Touch code examples from Obj-C to Swift by learning to use Closures, Enums, Switch-Case with Pattern matching, Singleton, GCD, CoreGraphics. Presented at Tel Aviv iOS Developers Meetup.

Phactory is an alternative to database fixtures for defining test data in PHP unit tests. It allows developers to define database objects in code and dynamically create them, rather than loading static datasets. Phactory provides a lightweight ORM and works with MySQL, SQLite, and MongoDB. It supports defining object blueprints, creating objects with associations, retrieving objects, and integrating with PHPUnit for testing database code.

The document discusses various code smells related to dependency injection and constructor usage, such as constructors doing real work instead of just setting fields, digging into collaborator objects instead of using their interfaces, and relying on global state and singletons. It provides examples of these code smells and proposes fixes using dependency injection and interfaces to make the code more testable and flexible.

Slides from my talk during PHPCon Poland. Szczyrk 25/10/2013 More Domain-Driven Design related content at: https://domaincentric.net/

Slides from my talk presented during SymfonyLive London - 18 September 2015. More Domain-Driven Design related content at: https://domaincentric.net/

The document discusses techniques for enabling communication between JavaScript and Objective-C in iOS applications, including setting global variables accessible to both, making Objective-C selectors and properties available to JavaScript, and handling callbacks from JavaScript to Objective-C such as when the web view location changes or a form is submitted. Code snippets provide examples of implementing these techniques.

This document discusses integrating Java Contexts and Dependency Injection (CDI) with other Java technologies like Spring and JavaServer Faces (JSF). It covers CDI concepts like the Inversion of Control pattern and dependency injection. It also provides examples of using CDI with Spring, integrating CDI and JSF, and using CDI interceptors. The document recommends some libraries for CDI integration and provides sample code links.

The Fetch API is a modern replacement of the XMLHTTPRequest object. It is based on promises and makes making AJAX/API calls easier to manage and code. This slide deck is a quick introduction to the API.

The document discusses integrating ReactJS and Webpack into Ruby on Rails applications. It covers using modules with CommonJS, RequireJS, and ECMAScript 6. It also discusses using Webpack for bundling assets, setting up entry points, loaders, and plugins. Webpack can be configured to work with Rails by defining webpack.config.js and using the assets:webpack task for deployment. This provides a modular approach for JavaScript development while still leveraging Rails.

Android and the Seven Dwarfs from Devox'15 Butterknife Dagger Volley / OkHttp / Retrofit GreenBus / Otto GreenDAO / Schematic Priority JobQueue Timber / Hugo Retrolambda

The talk presents how we established a TDD cycle within the complex AEM technology stack using a "unified testing API". It illustrates how such an API can be built and discusses various advantages over other approaches such as the Sling Testing API.

This document discusses dependency injection (DI) and inversion of control (IOC) design patterns. It explains that DI allows defining dependencies externally rather than hardcoding them, improving testability. IOC builds on DI by having a lightweight container manage object construction and dependency graph. The document uses JavaScript examples to demonstrate an InversifyJS library that implements IOC for JavaScript applications in a similar way that Spring Framework does for Java apps.

This document discusses using a portlet API-based approach for integrating applications into Magnolia. It describes the portlet API concept of separate action and render phases. Implementing portlets as JSR-168 components allows seamless integration into Magnolia by adding a portlet filter and rendering portlets during page generation. Configuration is done through content types and portlet parameters can be accessed. Real-world use has shown this approach works well for small applications but has limitations for more complex integrations.

The document summarizes what's new and noteworthy in Java EE 8, including updates to CDI 2.0, Bean Validation 2.0, JPA 2.2, JSF 2.3, JSON-B 1.0, Servlet 4.0, JAX-RS 2.1, and odds and ends like JSON-P and the Java EE Security API. It also discusses the status of Java EE 8 implementations from GlassFish, Payara, and Open Liberty, as well as the future of Java EE.

Presented at GeeCON 2011: JavaFX Script is going away, but the JavaFX Platform is getting a new face with pure Java APIs. In this session, you will see how you can leverage the new JavaFX 2.0 APIs from a host of different JVM languages, including JRuby, Clojure, Groovy, and Scala.

JavaFX is more than a language. It is also a platform for building immersive applications with graphics, animation, and rich media. In this session, you will see how you can leverage JavaFX from a host of different JVM languages, including Java, JRuby, Groovy, Scala, and Clojure.

Jenkins User Conference 2012 Only by the third plugin do you get the hang of writing a plugin. I thought as a developer coming to the build side of things it'd be easy to jump in and write some plugins. I was wrong. Don't be fooled by the extremely friendly Jenkins community, writing a plugin from scratch is harder than they let on. This talk will explain the hurdles that I had to cross to make writing plugins easy.