Talks

Presentations offered by Daniel Hinojosa

Scala For Java Developers

Choose...
  • 3 hours for light introduction
  • Full day workshop for a more aggressive introduction
Scala for Java Developers is a full live code and fast paced presentation and workshop (laptops optional), and this is all about the Scala language.
Scala is a wonderful functional/hybrid language. Scala, as opposed to some of the other languages, has quite a learning curve. This workshop was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala. Laptops optional so you can try stuff out on your machine and create questions of your own!

Beginning Spark

Apache Spark is the fast data processing of large document stores and databases. Spark is highly distributed, optimized, and redundant for large clustering manipulation and aggregation.
This talk is an introduction to Apache Spark, it's architecture, and it's programming API. We start with an introduction to DataFrames, the Catalyst Optimizer, and Spark SQL.

Spark Streaming

Spark Streaming is one of the few additions that are available with Spark that uses its internal architecture and creates a Streaming processing framework to process data in real time.
In this presentation, we will start with a small reintroduction to Spark and it's architecture and what it does. Then we delve into streaming, what purpose does it serve, how to set up Spark Streaming and how to use it. We will discuss how to set it with time, how the internals work, and how also to integrate it with Kafka. We then will talk about some of the more high-end features like checkpointing, and windowing.

RXJava

ReactiveX is a set of Reactive Extensions developed by Netflix, and is developed for various programming languages, like Java, Scala, and Clojure. ReactiveX overhauls the Observable design pattern to achieve reactive goals. This presentation will solely focus on the Java version of ReactiveX, RXJava.
RXJava is combining the Observer Pattern with Functional P rogramming to compose complex asynchronous reactive systems. This presentation will also give an overview on RXJava concepts like sources, sinks, back pressure and reactive pull and push.

Reactive Programming in Elm

The silent and deadly competitor to React and Angular. Meet Elm. All functional and client language. Clean.
This presentation discusses Elm, how to set up Elm and use it to design a better web client using tenets of functional programming. We discuss some of the simple ideas of the language and talk about how it uses its own MVC style architecture. Other items include:
  1. Functions
  2. Function Application
  3. Modules
  4. Currying
  5. Records
  6. Commands
  7. Subscriptions
  8. Tasks
  9. Elm Architecture

Kafka and Streaming

Kafka has captured mindshare in the data records streaming market, and in this presentation, we knock on its door and see what lies behind. What is the draw? What makes it an attractive addition? How does it compare to Message Queues and other message streaming services?
We will do a thorough introduction into what is Kafka. We will also discuss Consumers, Producers, Streams. Integration with ZooKeeper, and discuss the performance aspect of using Kafka.

Testing the Undesireable

In reality, our jobs aren't dealing with new code, but old crufty and evil code. How do we test such code, how do we get through it? How can we surgically take some of this bad code apart and make it testable.
This presentation looks at bad code and we talk about some of the strategies that we can do to diagnose, test, apply, and finally refactor to produce something that would promote some sanity in your development process. The content of this presentation is all in Java and JUnit.

Java Serialization for Big Data

Serialization is important for anything Big Data. We need to send information over the wire and we need to do so efficiently. This core concept presentation covers various serialization techniques and libraries. That way you can use Akka, Kafka, Spark, and various MQs efficiently.
For this presentation, we will focus on three topics: Core Java Serialization, Apache Avro, and Google's Protocol Buffers. We will review serialization and deserialization ease of use, review performance, and how to integrate with Akka, Kafka, Spark.

Akka and Java

A set various tools to write reactive, concurrent, fault-tolerant applications and services using immutable data, asynchronous message passing using local and remote actors, software transactional memory, and supervised systems. This entire presentation is done in Java.
Akka is a set of various tools to write reactive, concurrent, fault-tolerant applications and services using immutable data, asynchronous message passing using local and remote actors, software transactional memory, and supervised systems.
Akka is also part of the Lightbend stack, a stack that include the Play web framework, Spray, Slick, and the Scala programming language. This Akka presentation will cover Java style usage of Akka with actors, asynchronous message passing, supervision, and streams

Akka and Scala

A set various tools to write reactive, concurrent, fault-tolerant applications and services using immutable data, asynchronous message passing using local and remote actors, software transactional memory, and supervised systems. This entire presentation is done in Scala.
Akka is a set of various tools to write reactive, concurrent, fault-tolerant applications and services using immutable data, asynchronous message passing using local and remote actors, software transactional memory, and supervised systems.
Akka is also part of the Lightbend stack, a stack that include the Play web framework, Spray, Slick, and the Scala programming language. This Akka presentation will cover Scala style usage of Akka with actors, asynchronous message passing, supervision, and streams

Understanding JVM Futures

Starting with JDK 5, we have had Futures, and they mostly went ignored. Now with concurrency and reactive technology in demand, it is essential that we understand what futures are, and how to handle them and make use of their power in asynchronous systems.
This presentation is a basic ground up introduction to Futures. We start with Futures and how they came packaged with JDK 5. We take a look at Executors, how to create a thread pool, which pool you should choose. How to model Futures in the JDK and show the difference for awaiting the answer and taking on the answer asynchronously. We also take a look at what a Promise is and when to use one. We then invest time taking a look at Guava's callback solution. Then we finally look at the handling of futures in both Scala and Clojure.

Testing in Scala

Most introductory programming books include a chapter on testing, seemingly as an afterthought. For the test-driven developer, that's a little too late. Some programmers approach a new programming language with a few test-cases to understand a concept. Others thrive under fire and want to hit the ground running in a new programming language by creating an application.
It just so happens that testing code in Scala is a great way to learn Scala, but also really good at testing Java code. This presentation started a book on how to use some of the greatest tools that you can use to test. This presentation will cover ScalaTest, Specs2, ScalaMock and ScalaCheck all in a triggered execution environment using SBT. For those that do not wish to use SBT, we will cover other options as well. Using these tools you may never want to use those plain jane java testing frameworks ever again. While this presentation is not interactive, all demos will be available on github for those that want to “play” along with their laptops.

More Functional in Java with Vavr

Java 8 is pretty great, but mix in JavaSlang (now called Vavr) and get ready for some functional programming excitement.
JavaSlang is a project that decorates Java with immutable data structures, better Optionals, tuples, and more. Now with JavaSlang (Vavr) we can really bring in some more power to functional programming and Java. We will even discuss some new concepts like for comprehensions,
Try
, and
Either
!

Java 8 Date Time API

Finally, the Java 8 Date Time API will be in our grasps and now we will celebrate gleefully in the streets! ISO8601 and UTC standards! Immutability! Time to set attention to stun as this presentation will cover all the goods about the new Date/Time API that makes Java programming safe.
We cover in 90 Minutes: ISO 8601 & UTC Instants Periods Durations Parsing Time Zone Manipulations and Updates Conversion from Old Java Date Times Whatever else we can cram into the presentation
This will interactive for the most part with few slides. Bring on your questions.

IntelliJ Jedi Tricks

This presentation is the Dagobah of efficient editing and flow. Come only what you take with you.
Most efficient you will be, when keyboard tricks learned. You'll see. Hmmmm. You must unlearn what you have learned. A Jedi's power comes from knowledge of the tools used. Luminous beings are we… not crude typists. Mouse is your weakness. Learn to use more of the keyboard, you will.
Learn:
  1. Window Management
  2. Programming Flow
  3. Templating
  4. Version Control Management
  5. Alternate Language Goodness
  6. Tool Fu

Playing with the Play Framework in Java

This presentation will cover an introduction to the framework by creating a basic web application in Java to get you started.
The Play Framework is a lightweight and stateless web framework that is part of the Lightbend stack, a stack which includes Akka, a reactive message driven toolkit, and the Scala programming language (Although this session will use the Java API). The presentation will cover an introduction to the framework by creating a basic web application in Java to get you started. The presentation will also cover the philosophy behind the framework and give an honest analysis on the advantages and disadvantages of the framework.

Playing with the Play Framework in Scala

This presentation will cover an introduction to the framework by creating a basic web application in Scala to get you started.
The Play Framework is a lightweight and stateless web framework that is part of the Lightbend stack, a stack which includes Akka, a reactive message driven toolkit, and the Scala programming language. The presentation will cover an introduction to the framework by creating a basic web application in Java to get you started. The presentation will also cover the philosophy behind the framework and give an honest analysis on the advantages and disadvantages of the framework.