Tech Tutorials: 2014

Sunday, December 7, 2014

Security for Microservices with Spring and OAuth2

OAuth2 is a lightweight security protocol that is well-suited for use with HTTP, the protocol at the heart of many modern architectures. Spring Security OAuth2 has a load of new features, not the least of which being the `@Configuration` support in version 2.0. Combine these with Spring Boot and you have a platform which can get you a secure HTTP service application in about 20 lines of code. This presentation shows how the combination of rapid development and production-ready features in the modern Spring stack are a perfect mixture for developing secure components in a system composed of microservices. We explore the new features in Spring OAuth2, guide you through the choice of which to use and when, and show how easy they are to enable quickly.

Source: https://www.youtube.com/watch?v=MLfL1NpwUC4

Tuesday, October 28, 2014

IoT Realized with Spring XD - The Connected Car

In this demo we will explore the power of Spring XD in the context of the Internet of Things (IoT). We will look at a solution developed with Spring XD to stream real time analytics from a moving car using open standards. Ingestion of the real time data (location, speed, engine diagnostics, etc), analyzing it to provide highly accurate MPG and vehicle range prediction, as well as providing real time dashboards will all be covered. Watch this demo to get a sense of how Spring XD can serve as “Legos®” for the IoT.

Source : https://www.youtube.com/watch?v=qkm2GV57hzY

Why Do I recommend Spring?

Is Spring the new legacy as quite a few people tell you on their blogs? I disagree on many levels. Throughout this session I will holistically detail without any polemics why I do recommend using the Spring Framework and its ecosystem. Aspects that will be covered include: operational impacts, ecosystem, coding and road maps. This presentation is aimed at IT managers, Architects and Developers alike.

Source: https://www.youtube.com/watch?v=z1rpWpSKtT8

Architecting for Continuous Delivery: Microservices with Pivotal CF and Spring Cloud

Join Matt Stine to hear how you can architect systems that are optimized for continuous delivery, allowing you to innovate and deliver value faster and safer. Microservices, Pivotal CF, and Spring Cloud combine to create an operationalized architecture that enables enterprises to continuously deliver value at scale through rapid, iterative development, and to meet the needs of a mobile-first world.

Sunday, August 31, 2014

Introducing Project Wing

Project Wing is a Google[x] project that is developing a delivery system that uses self-flying vehicles. As part of our research, we built a vehicle and traveled to Queensland, Australia for some test flights. There, we successfully delivered a first aid kit, candy bars, dog treats, and water to a couple of Australian farmers. We’re only just beginning to develop the technology to make a safe delivery system possible, but we think that there’s tremendous potential to transport goods more quickly, safely and efficiently.

Tuesday, August 12, 2014

Example HTML File to display Overlay using JQuery

Copy past the below html code into one html file then access the html in browser to see the Overlay functionality.

<html>
<head>
<title>Sample Overlay Test</title>
<link href=”css/jquery-ui.min.css” rel=”stylesheet” type=”text/css” />
<script src=”js/jquery.min.js”></script>
<script src=”js/jquery-ui.min.js”></script>

<style type=”text/css”>
#displayOverLayDiv {
width: 500px;
height: 500px;
display: none;
}

.overlay {
position: absolute;
top: 0;
left: 0;
display: none;
background-color: black;
background: url(“http://malliktalksjava.in”);
}

#frame {
border: 0;
width: 500px;
height: 500px;
}

#open {
border: 0;
width: 175px;
height: 24px;
background-color: #EAF8F8;
font-size: 18 px;
font-weight: bold;
}
</style>

<script type=”text/javascript”>
$(document).ready(function () {
$(‘#open’).click(function () {
$(“.overlay”).height($(window).height());
$(“.overlay”).width($(window).width());
$(“.overlay”).fadeTo(1000, 0.4);
$(“#displayOverLayDiv”).dialog({
width: “auto”,
height: “auto”,
show: {
effect: “slide”,
duration: 1500
},
hide: {
effect: “slide”,
duration: 1500
},
beforeClose: function () {
$(“.overlay”).fadeTo(1000, 0);
},
close: function () {
$(“.overlay”).css(“display”, “none”);
},
resizeStop: function (event, ui) {
$(“#frame”).height($(this).height());
$(“#frame”).width($(this).width());
}
});
});
});
</script>
</head>

<body>
<div id=’open’>
<a href=”#”>Click here to Get Overlay</a>
</div>
<div class=’overlay’>
<div id=’displayOverLayDiv’>

</div>
</div>
</body>
</html>

Wednesday, July 23, 2014

REST-ful API Evolution

As REST-ful data services become more widespread, it is becoming clear that they have to change to suit new consumer needs. This evolution is often disruptive to consumers, but it doesn't have to be. This session, a follow up to 'REST-ful API Design', discusses various strategies for evolving a REST-ful API and how the strategies can be implemented using Spring.

Source: https://www.youtube.com/watch?v=fSFh9UCBp5s&list=UU7yfnfvEUlXUIfm8rGLwZdA

Integrating Spring Batch and Spring Integration

This talk is for everyone who wants to efficiently use Spring Batch and Spring Integration together. Users of Spring Batch often have the requirements to interact with other systems, to schedule the periodic execution Batch jobs and to monitor the execution of Batch jobs. Conversely, Spring Integration users periodically have Big Data processing requirements, be it for example the handling of large traditional batch files or the execution of Apache Hadoop jobs. For these scenarios, Spring Batch is the ideal solution. This session will introduce Spring Batch Integration, a project that provides support to easily tie Spring Batch and Spring Integration together. We will cover the following scenarios: Launch Batch Jobs through Spring Integration Messages Generate Informational Messages Externalize Batch Process Execution using Spring Integration Create Big Data Pipelines with Spring Batch and Spring Integration.

Source: https://www.youtube.com/watch?v=8tiqeV07XlI

Building app management tools with Spring Boot

Spring Boot lets you write apps better than ever. But did you ever think about writing all those support scripts and tools you inevitably need with Boot as well? In this webinar, see how the Spring team has already picked up and run with Spring Boot CLI as a powerful way to manage things like all open issues against the 60+ getting started guides. See how to monitor application logs using a little Spring Integration, Spring WebSocket+STOMP, and other technologies, all with some lightweight Boot+Groovy code.

Source: https://www.youtube.com/watch?v=j3rrqOV68ik

Building a Shopping Cart in 24 Hours using Spring

Creating a transactional website that is secure, fast, and responsive is a challenge all on its own. Creating one in 24 hours borders madness, however with the resources that Spring brings to the table, this can be accomplished. Casey Doolittle and Phil Dutson were issued the task of creating a charity-benefit website two days before the sale started. By leveraging the flexibility and power that various Spring components bring to the table, this mighty feat was accomplished. During this talk Casey and Phil will discuss the how and why of using Spring 3.2.4, Spring Web MVC, and Spring Security 3.1.4 as their framework of choice to get the project done on time.

Source: https://www.youtube.com/watch?v=QBfuTBJv3qE

Thursday, May 22, 2014

Introduction to Apache Tomcat 8

Apache Tomcat 8 implements new versions of the Servlet, JSP and EL specifications as well as adding support for the new WebSocket specification. Work has also been completed on internal refactoring in a number of areas that will impact a number of Tomcat specific features.

This presentation will provide an overview of the changes and new features introduced by both the updated specifications and the Tomcat specific changes. This session will enable attendees to identify the Tomcat 8 features of greatest interest to them and provide them with the information required to start planning their migration to Tomcat 8.

Source: www.youtube.com/embed/nHdyBjb9gbU?list=PLgGXSWYM2FpNmY5a1MuomSvvovSWHWoAR

Getting started with Spring Data and Apache Hadoop

Big data and Hadoop is widely considered to be the next generation data platform. Hadoop is notoriously difficult to work with and just diving in and starting coding can easily lead to frustration. A better way is to leverage your existing Java and Spring skills to take advantage of these new technologies. In this presentation we will introduce Spring Data for Apache Hadoop and see how it can make working with Hadoop easier. We will also cover several ways to install a small Hadoop cluster that can be used to test your new Hadoop applications.

Source: https://www.youtube.com/watch?v=tIPA6vMZomQ&index=3&list=PLgGXSWYM2FpOXky1eHFbX0Eb0I58YmCNS

Introducing Spring XD

Developing Big Data applications is a relatively new art and developing a comprehensive solution can be challenging. Some of the key challenges arise from bringing together complex domains such as stream analysis, batch workflow orchestration and data import and export.

Several open source projects that address developing big data applications have emerged in the past few years but each project typically only address one of these domains.

Furthermore, being distinct independent projects they have different configuration and extensibility models. Spring XD is a new project that aims to tackle big data complexity. It builds upon proven Spring technologies and provides a scalable run time environment that is easily configured and assembled via a simple DSL.

Come discover how easy it is to create big data applications in this introduction to Spring XD.

Source: www.youtube.com/embed/3Wycvyqn0n4?list=PLgGXSWYM2FpOXky1eHFbX0Eb0I58YmCNS

Spring Integration Internals

A comprehensive review of message routing within a flow - including exactly how and when replyChannel and errorChannel headers are used how and when these headers apply in an error flow differences between synchronous and asynchronous processing (with task executors and pollers) Use of SpEL (for messagemethod mapping as well as certain "dynamic" config attributes) Type conversion (via SpEL, datatype channels, etc) Implicitly created channels How chains work How messages are mapped to methods when a message arrives at a component How gateway methods are mapped to messages (and a first look at some enhancements we are considering) Options for synchronous and asynchronous flows simple multi-threading aggregation aggregating messages from different sources How to debug Spring Integration applications Advanced configuration techniques

and more...

This presentation will be mainly demonstration and code walkthroughs.

Source: https://www.youtube.com/watch?v=mF2uq4DnVCg

Wednesday, May 21, 2014

Migrating from WLS, WAS, JBoss to Pivotal tc Server

Source: https://www.youtube.com/watch?v=qfV4Bl80dJo

Zero to Stream processing in 7 minutes with Spring XD

Creating a stream of live twitter data for an analytics dashboard using Spring XD, a JavaScript D3 component / Spring XD's REST API.

Source: https://www.youtube.com/watch?v=nOfzrQ6CdKI

Virtualizing and Tuning Large Scale Java Platforms

The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs.

In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover Pivotal App Fabric reference architecture where a comprehensive performance study was done.

Source: https://www.youtube.com/watch?v=htxkAMiAD58

Sunday, May 18, 2014

Going Beyond Dependency Injection

Many developers who are learning the Spring Framework think of it as simply another mechanism for centralized dependency injection. While the framework does handle that responsibility quite well, the framework is so much more. In this session, we'll explore some of the building blocks and patterns used by the core framework as well as many of the other Spring projects. The result is that attendees will gain a better understanding of how to use the Spring Framework and learn how to build their own components that can leverage these same patterns. Topics we'll explore:
- What is the benefit of centralized life-cycle management
- Programming to interfaces
- Leveraging the power of proxies
- Using annotations
- Understanding the template pattern

Dependency injection is one very important part of what the Spring Framework does. However, it is also a collection of very key patterns that we'll explore.
- Centralized life-cycle management
- Examining the BeanFactoryPostProcessor
- Examining the BeanPostProcessor
- How to write your own BeanPostProcessor
- Programming to interfaces
- Benefits of programming to interfaces
- loose coupling
- Examples of how Spring leverages this mechanism
- How to leverage in your own Spring applications
- Leveraging the power of proxies
- How proxies work in Spring
- How Spring uses them
- Writing your own proxy-based solution
- Using annotations
- Examples of how Spring uses annotations
- Using your own annotations
- Understanding the template pattern
- Purpose of template pattern
- How Spring uses templates
- Creating your own template

Source : https://www.youtube.com/watch?v=JfgP566BHW0

Getting Started with Spring Security 3.2

Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Like all Spring projects, the real power of Spring
Security is found in how easily it can be extended to meet custom requirements. In this presentation Rob will incrementally apply the new features found in Spring Security 3.2 to an existing application to demonstrate how it can meet your authentication and authorization needs.

Source: https://www.youtube.com/watch?v=1zu8COg80q4

spring.io inside and out

Spring Integration 4.0 - The New Frontier

With this Spring Integration 4.0 release, the existing basic annotation support has received an overhaul and those who prefer to use java @Configuration classes can now define their applications without needing to use any XML (of course, XML is still supported as well).

In this session we will cover these major changes to the framework, explaining how and when to use them. It will be mainly demonstration and code walk through, and we will build a useful Spring Boot / Integration application from scratch.

Source : https://www.youtube.com/watch?v=g3DgdSqEgzI

Thursday, April 24, 2014

Spring Framework 4 on Java 8

Spring has a track record of providing dedicated support for new Java generations in a timely fashion, and now it's right about time to go Java 8: With Spring Framework 4.0, we're providing in-depth support for all relevant OpenJDK 8 features, including lambda expressions, JSR-310 Date and Time, parameter name discovery, and java.util.concurrent enhancements.

This talk will illustrate basic Spring Framework 4.0 concepts, and selected Java 8 features within Spring's programming model, exploring the impact on application architectures.

Building For Speed - Tips and Tricks for Client-Side Performance

As the complexity of web and mobile apps increases, so does the importance of ensuring that your client-side resources load and execute in an optimal and efficient manner. Differences in resource loading techniques can have a dramatic impact on how fast an application feels to your users, and can be the catalyst for whether they have a joyful or frustrating experience. This talk will discuss performance techniques aimed at keeping your users on the joyful end of this user experience spectrum.

We'll take a look at: Pragmatic tools for measuring client-side performance Techniques for optimizing resources and their resulting impact Approaches to maximizing dev-time happiness and production performance Easy incorporation of these techniques into your everyday tool-chain.

In-memory data and compute on top of Hadoop

Hadoop gives us dramatic volume scalability at a cheap price. But core Hadoop is designed for sequential access - write once and read many times; making it impossible to use hadoop from a real-time/online application. Add a distributed in-memory tier in front and you could get the best of two worlds - very high speed, concurrency and the ability to scale to very large volume. We present the seamless integration of in-memory data grids with hadoop to achieve interesting new design patterns - ingesting raw or processed data into hadoop, random read-writes on operational data in memory or massive historical data in Hadoop with O(1) lookup times, zero ETL Map-reduce processing, enabling deep-scale SQL processing on data in Hadoop or the ability to easily output analytic models from hadoop into memory. We introduce and present the ideas and code samples through Pivotal in-memory real-time and the Hadoop platform.

Multi Environment Spring Applications

It'd be nice to assume everything remains the same from one environment to another, but the realities of today's deployment targets (clouds, app servers, etc.) make this difficult. An application may target one in-memory database in development and target a traditional database in production. A/B testing is a common practice that lets you incrementally expose potentially high risk features. Feature switches can be invaluable; should something go wrong, you can revert to a known state. All of these use cases, and more, can be handled using the Spring framework.

Join JavaOne Rock Star and Java Champion Kevin Nilson and Spring Developer Advocate Josh Long for a look at how you can run your application in differing environments using the Spring Framework.

Building Smart Clients with Spring

No application is an island and this is more obvious today than ever as applications extend their reach into people's pockets, desktops, tablets, TVs, Blu-ray players and cars. What's a modern developer to do to support these many platforms? In this talk, join Josh Long to learn how Spring can extend your reach through (sometimes Spring Security OAuth-secured) RESTful services exposed through Spring MVC, HTML5 and client-specific rendering thanks to Spring Mobile, and powerful, native support for Android with Spring Android.

Building 'Bootiful' Applications with Spring Boot

Spring Boot, the new convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant!

Your Data, Your Search, Elasticsearch

Finding relevant information fast has always been a challenge, even more so in today's growing "oceans" of data. This talk explores the area of real-time full text search, using Elasticsearch, an open-source, distributed search engine built on top of Apache Lucene. The session will showcase how to perform real-time searches on structured and non-structured data alike, how to cope with types and suggestions, do social graph filters and aggregations for efficient analytics. All from a Spring perspective Last but not least, the presentation focuses on the Hadoop platform and how Map/Reduce, Hive, Pig or Cascading jobs can leverage a search engine to significantly speed up execution and enhance their capabilities.

The presentation covers architectural topics such as index scalability, data locality and partitioning, using off and on-premise storages (HDFS, S3, local file-systems) and multi-tenancy.

Application Security Pitfalls

Creating a secure application involves more then just applying Spring Security to it. This is of course not a new topic, but with the increased popularity of much more dynamic configurations for Servlet Containers and various Spring Projects, like Spring MVC and Spring Integration, it becomes more important to know about the Security tradeoffs we might get with that, and how to tackle them.

Source: https://www.youtube.com/watch?v=Id-7C3WOKWw

Wednesday, April 9, 2014

Top 10 aspects to consider before buying a Laptop

There is a wonderful article in Economic Times explaining about top 10 aspects to consider before purchasing a laptop.

It explains about touch screen, storage, optical drives. It suggests to choose thinner, lighter and log battery life laptops. It gives multiple options to choose correct laptop which suits our needs.

Gothough the below link for more information:

http://economictimes.indiatimes.com/tech/hardware/planning-to-buy-a-laptop-here-are-10-aspects-to-consider/articleshow/33477790.cms

Tuesday, April 8, 2014

AOP-ing your JavaScript

Aspect Oriented Programming (AOP) is a technique for augmenting the behavior of objects, methods, and functions non-invasively. AOP adds new behaviors and modifies existing behaviors "from the outside". Using AOP, it's possible to create connections between components without either having any knowledge of the other and without any extra library dependencies in your code.

While you may be familiar with AOP in Spring, you may not yet have applied it in JavaScript. In this talk, we'll do just that. We'll introduce simple techniques for applying AOP in pure JavaScript using no additional libraries, and then look at meld.js (https://github.com/cujojs/meld), the AOP library that powers Cujo.js (http://cujojs.com). We'll work from simple examples of making connections between components to more sophisticated examples that integrate pubsub, message buses, etc. in a truly loosely coupled way.

Source: https://www.youtube.com/watch?v=MoZgJY2IF4A

Monday, April 7, 2014

Real Time Analytics with Spring

Today's solutions must provide the ability to interpret related events and understand trends that are happening right now. This session will cover some of the out of the box capabilities of Spring XD to tap into big data streams and generate metrics such as simple counters, aggregate counters, moving averages, rates of change, and histograms. Hands-on demos will show you how Spring XD uses Redis and GemFire's Continuous Query and Function Execution to incorporate real-time analytics into event-driven applications.

Source: https://www.youtube.com/watch?v=g1tTK5PsvjE

Friday, April 4, 2014

Intro To WebSocket Applications with Spring Framework 4.0

This update to last year's presentation, covers the new standard Java WebSocket API (JSR-356) including a discussion of positives and limitations, an update on the current status of WebSocket support across Servlet containers, and of course the Spring Framework 4.0 WebSocket support -- how to configure and use it and what additional benefits it provides. A central part of this is Spring's support for SockJS, the protocol for transparent WebSocket fallback options for use in applications that for example need to run in IE 10 and eariler.

This presentation is for you if you want a comprehensive introduction to WebSocket including standard Java EE 7 and Spring Framework 4.0 support. For a more practical take on how to actually build WebSocket-style applications that skips the introduction, please attend the next presentation Building WebSocket Browser Applications with Spring by Rossen Stoyanchev and Scott Andrews, or attend both presentations. They are intended to be complementary.

<iframe width="640" height="360" src="//www.youtube.com/embed/MJeEAVJR2FA" frameborder="0" allowfullscreen></iframe>

SOURCE: http://www.youtube.com/watch?v=MJeEAVJR2FA

Real Time Analytics with Spring

Today's solutions must provide the ability to interpret related events and understand trends that are happening right now. This session will cover some of the out of the box capabilities of Spring XD to tap into big data streams and generate metrics such as simple counters, aggregate counters, moving averages, rates of change, and histograms. Hands-on demos will show you how Spring XD uses Redis and GemFire's Continuous Query and Function Execution to incorporate real-time analytics into event-driven applications.

<iframe width="640" height="360" src="//www.youtube.com/embed/g1tTK5PsvjE" frameborder="0" allowfullscreen></iframe>

Source : http://youtu.be/g1tTK5PsvjE

Wednesday, April 2, 2014

Running Spring in Amazon Web Services

Running applications in the cloud presents a set of interesting new problems, constraints and opportunities. In this talk, attendees will learn how best to deploy, run and manage their Spring applications in the Amazon cloud.

Covering everything from basic applications in Amazon Beanstalk to large-scale applications that span multiple regions and interact closely with on-premise resources, this talk will equip attendees with the knowledge they need to be successful running Spring in the cloud.

Source: https://www.youtube.com/watch?v=huUPkAfCwU8

Hadoop - Just the Basics for Big Data Rookies

This session assumes absolutely no knowledge of Apache Hadoop and will provide a complete introduction to all the major aspects of the Hadoop ecosystem of projects and tools. If you are looking to get up to speed on Hadoop, trying to work out what all the Big Data fuss is about, or just interested in brushing up your understanding of MapReduce, then this is the session for you. We will cover all the basics with detailed discussion about HDFS, MapReduce, YARN (MRv2), and a broad overview of the Hadoop ecosystem including Hive, Pig, HBase, ZooKeeper and more.

Sunday, January 19, 2014

Building Your Java Configuration Muscle Memory

Using a module that provides a Spring XML namespace and integration API is muscle memory for most people: add the .xsd to the imported XML schemas for the configuration file, maybe enable a annotation-driven variant if it's available, autocomplete some XML stanzas, and then you're set! But what about Java configuration? Java configuration has been around in some form since at least 2005. It was merged into the core framework in 2009 and since then we've seen a slew of new Java configuration-powered DSLs pop up. 2013, in particular, has seen alpha-or-better cuts of Java configuration support for Spring MVC, Spring Security (and Spring Security OAuth), Spring Batch, Spring Social, Spring Data (including all the modules under it: REST, MongoDB, JPA, Neo4j, Redis, etc), Spring HATEOAS, and more all provide milestone-or-better cuts of a Java configuration integration. Tomcat 7 (and all Servlet 3-compatible containers) offer a programmatic alternative to web.xml. This provides another great integration hook for modules that wish to integrate with the web container, removing the configuration burden from the user. There's a lot of power here and it's easy to get started if you know what to look for. In this talk, join Spring Developer Advocate Josh Long and Spring-core commmitter, all-around nice guy, and Spring Boot ninja Phil Webb as they introduce the Java configuration support in the various Spring projects, show how to approach them when integrating them into your code, and - if the situation demands - how to write your own Java configuration DSL.

Source : http://www.youtube.com/watch?v=-4BQXNufpbQ

Spring RESTBucks - A hypermedia-driven REST webservice

Spring MVC forms a solid foundation to implement REST based web-services in Java. However, in real-world projects developers still face challenges when it comes to advanced questions of REST. How to really leverage hypermedia? How to model more complex business functionality with REST. The talk introduces the Spring RESTBucks sample implementation of a hypermedia-driven REST web service and explains how it is using hypermedia elements to implement business processes and how Spring technologies (Spring Data REST, Spring Data JPA and Spring HATEOAS) help developers building the system.

Source : http://www.youtube.com/watch?v=Y3rP4VT7qWM

REST-Ful API Design

As data-driven applications become more widespread, the services that provide the data are becoming more critical. Most commonly these data services are exposed via REST-ful APIs. This session describes what exactly makes a service REST-ful, how to implement a REST-ful API using Spring, and how to test that API.

Source : http://www.youtube.com/watch?v=oG2rotiGr90

Saturday, January 18, 2014

Spring with Immutability

One of the primary issues faced by enterprise Java programmers seeking to utilize immutable classes are framework issues. Enterprise frameworks from Spring to Hibernate have varying levels of support for immutability, ranging from decent to nonexistent. However, there several practical solutions available to the Spring developer, and this session will illuminate what's available.

Source : http://www.youtube.com/watch?v=D8eCUR0QK-s

Saturday, January 11, 2014

Spring - Reactor

Reactor is a succinct and powerful foundational library for building reactive, fastdata applications on the JVM. Although it is part of the Spring IO platform, the core Reactor libraries have no dependency on Spring. Above the core library, there's direct support for the Disruptor via the high-speed Processor abstraction which provides a Reactor API over the RingBuffer, first-class support for the high-performance JavaChronicle persistent message-passing library through the flexible PersistentQueue abstraction, first-class support for Groovy closures and @CompileStatic, high-performance TCP client and server support based on Netty 4.0, powerful annotation-based Spring support, and much more. Join Jon Brisbin at the event to get introduced to the first major GA release of Reactor, and learn how Reactor's Promise and Stream APIs are used to wrangle the inherent complexity of asynchronous, event-driven application code.

Source : http://www.youtube.com/watch?v=S6-L4xws9l0

Spring RESTBucks - A hypermedia-driven REST webservice

Data Modelling and Identity Management with OAuth2

The OAuth2 specification (wisely) leaves a lot of areas open to interpretation and implementation details, so there are a lot of opportunities to impose interpretations on the flows and the underlying data. This presentation starts with a basic guide to the main features of OAuth2 and then goes on to show, with examples, how they can be exploited to support business and application use cases. For instance, should you encode access decision data directly in the access token, or make the token completely opaque? Should you be signing requests? What naming convention should you use for OAuth2 scopes? How do you go about registering users and clients? There are some obvious patterns in existing OAuth2 implementations, and Spring Security OAuth provides plenty of hooks and extension points should you wish to copy one of those, or make your own rules.

Examples will use Spring and Spring Security to show how to take advantage of the inherent flexibility, both in the spec and in the libraries.

Source: http://www.youtube.com/watch?v=nMdtYnSXRpw

Building Your Java Configuration Muscle Memory

Basic Introduction to Apache Hadoop

Hadoop lets you manage big data. In this Basic Introduction to Hadoop Video, gives the introduction to Apache Hadoop, including the roles of key and related technologies in the Hadoop ecosystem, such as: MapReduce, Hadoop Security, HDFS, Ambari, Hadoop Cluster, Datanode, Apache Pig, Hive, HBase, HCatalog, Zookeeper, Mahout, Sqoop, Oozie, Flume and associated benefits.

Source: http://www.youtube.com/watch?v=OoEpfb6yga8

Menu Bar

Sunday, December 7, 2014

Tuesday, October 28, 2014

Sunday, August 31, 2014

Tuesday, August 12, 2014

Wednesday, July 23, 2014

Thursday, May 22, 2014

Wednesday, May 21, 2014

Sunday, May 18, 2014

Thursday, April 24, 2014

Wednesday, April 9, 2014

Tuesday, April 8, 2014

Monday, April 7, 2014

Friday, April 4, 2014

Wednesday, April 2, 2014

Sunday, January 19, 2014

Saturday, January 18, 2014

Saturday, January 11, 2014

Total Pageviews

Indiblogger Rank