Talks

Presentations offered by Daniel Hinojosa

Scala For Java Developers

Category: Scala
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

Category: Scala, Spark, ETL, Batch
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

Category: Scala, 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

Category: RXJava, Reactive, Java
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

Category: Elm, Javascript, Front-End, Browser Development
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

Category: Kafka, Kafka Streaming, Java
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

Category: Java, Testing
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

Category: Java, Serialization
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

Category: Java, Akka
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

Category: Scala, Akka, Messaging
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

Category: Java, Futures, Concurrent Programming
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

Category: Scala, Testing, ScalaTest, Specs2, ScalaCheck
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

Category: Java, Functional Programming, 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

Category: Java, Dates, Times
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

Category: Java, IntelliJ, Editors
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

Category: Java, Play Framework
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

Category: Scala, Play Framework
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.

Typelevel Cats

Category: Scala, Cats, Typeclasses
New 2019
Imagine toString, equals, and hashCode in a single class. Can you change implementations on the spot? Probably not, there may be too many dependencies on your implementation. Time to break out an adapter pattern, a utility class, or better yet, a type class! A type class is a kind of template in very static functional programming languages. Imagine a template that can read, write information as a side effect as well? Type classes are powerful.
For these various type-classes, we will be looking at a project called TypeLevel Cats. TypeLevel is a group of projects that adhere to a code of conduct, modular systems, static, functional, open source programming. TypeLevel Cats is the flagship project for Typelevel.
Our presentation will be following this story:
  1. Just a tiny bit of Scala
  2. Introduction to an implicit
  3. Introduction to a typeclass
  4. Using Cats
  5. Eq
  6. Monoid
  7. Monad
  8. Functors
Even if you are not a Scala Programmer, you may want to come in and see how type classes work because I am making a bet… This will be something that will be used by other JVM languages in the future. Kotlin doesn't have it now, Groovy doesn't have it now, TypeScript doesn't either although some projects are working towards this idea.

Graal the Magnificent

Category: Java, Virtual Machines
New 2019
Graal is a VM and an awesome VM at that. Able to run a variety of languages and fast. The execution times can be impressive too. This VM can run anything, JavaScript, Python 3, Ruby, R, JVM-based languages like Java, Scala, Kotlin, and LLVM-based languages such as C and C++.
We are living in truly exciting times. So much interesting technology including the VM space. Graal is a virtual machine and shared memory system for multiple languages. GraalVM can either run standalone or embedded in OpenJDK or node.js. Graal can even embed inside databases such as MySQL or Oracle. In the presentation, we look at this exciting VM, how to start it, how to run polyglot applications, a nd how to integrate all within the same VM.

Grokking Generics

Category: Java, Generics
Still grappling with Generics? This will be an attempt to clear the air about generics. What are wildcards? What is extends? What is super? What is covariance? What is contravariance? What is invariance? What is erasure? Why and when do I need this?
One of the more pain items in any statically typed language on the JVM is generics or parameterized type. This presentation is set to overcome some of these hurdles and understand some of these terms that often vex us. We will cover:
  1. Covariance
  2. Contravariance
  3. Invariance
  4. Erasure
  5. Generic Assignments
  6. Weird Generic Funky Stuff
  7. Use-Site vs. Declaration Site
  8. Alternate Languages (Java, Scala, Kotlin)

Pomodoro Technique

Category: Productivity, Softskill
Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it's done with a kitchen timer.
In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.

In Depth Kafka Streams and KSQL

Category: Kafka, Kafka Streams, KSQL, Streaming
Kafka is more than just a messaging queue with storage. It goes beyond that and with technology from Confluent open source it has become a full-fledged data ETL and data streaming ecosystem.
When we utter the words, Kafka, it no longer is just one component but can be an entire data pipeline ecosystem to transform and enrich data from source to sink. It offers different ways to handle that data as well. In this presentation, we will discuss briefly a variety of technologies outside of Kafka Streams and KSQL from the Confluent stack that contributes to the overall streaming experience: Kafka Connect and Registry Schema

Java 9 Reactive Streams

Category: Java, Reactive Streams
Many have already seen what Reactive Streaming can do: RXJava, Akka Streams, Project Reactor. Now reactive streaming is a part of the canonical package for Java and now we can handle asynchronous pipelines with boundaries and make better well thought out applications
This presentation introduces you to the core components of Reactive Streams:
Publisher
,
Subscriber
, and
Processor
. We will discuss when to use Reactive Stream and how to avoid complicated scenarios like Backpressure. We will also cover some of the core problem spaces and how to overcome.

Citrus Integration Testing

Category: Java, Testing, Integration Testing
An introduction to a framework that can help with testing some of the harder things to test. We will be doing integration testing for Http, JMS, SOAP, REST, WebSockets, TCP/IP, SMTP. All with timeouts, error control and capable in a variety of JVM Languages.
The novice developer develops code and sends their code to a server to see how well it runs and if it tests well. The round trip cost in doing so is expensive. The advanced developer tests their code first locally as best as they can before even initial deployment to a test server. They do so by swapping actual implementations with canned information. This is always done for unit testing but done strategically in integration. Integration testing will be our focus as we cover one of the interesting frameworks out there, Citrus. Citrus is a tool that will aid in integration testing and will aid in a variety of common things we need to test in our day to day lives.