[2019 oracle code one] Lambda, Streams and Collectors Lab

Lambda, Streams and Collectors Lab

Speakers: Stuart Marks, Maurice Naftalin, Jose Paumard & Gustavo Durand

For more blog posts, seeĀ The Oracle Code One table of contents


The lab is self paced

https://github.com/JosePaumard/code-one-2019-lambda-stream-collector-lab

I like that it is organized by topic so you can pick what you want to learn. Since “someone” believed I didn’t need to be here, I decided to blog about what I did and learned.

  • O_SimpleCollectors
    • I forgot Comparator.naturalOrder() exists because I hardly use it.
    • I forgot you can’t use Function.identity() with primitives and instead have to write a lambda: ex: x -> x.
  • P_HarderCollectors
    • I almost never use flatMap. I didn’t think to use it combined with splitAsStream to read words from a file. I do a lot of file processing though so this is definitely an idiom I need to remember! I shall type it in for each exercise in this lab that uses it (vs copy/paste) in order to ingrain it in my fingers! reader.lines().flatMap(SPLIT_PATTERN::splitAsStream)
    • The extra challenge to write a groupingBy using toMap. I knew I needed to use a merge function, but the types didn’t match my expectations. I learned that:
      • if you write a value instead of a lambda for the value function, you get a compiler error on the merge function (about the + operator being invalid ) and not the value function for not being a lambda
      • if you write a value function that returns an int instead of a long, you get a compiler error on the merge function and not the value function (because the merge function result is what gets set to the return value)
    • If you try to read from a reader that has already called reader.lines(), you don’t get any lines. Doh!
    • flatMap(String::chars) doesn’t work because chars() returns an IntStream. flatMapToInt(String::chars) does work
    • Entry has comparingByKey() and comparingByValue() methods
    • Remember to use groupingBy when aggregating and toMap when one to one
    • Need to call boxed() on an IntStream to be able to use partitioning by. An IntStream doesn’t have a collect method that takes a Collector as a parameter

My take

The lab is great. I like that it can be as easy or as hard as you want. I like they support multiple versions of Java and multiple IDEs.

The room is terrible. It’s not really a room. It’s a grid of pipe/drape separated areas. I can hear every word in the room next to us.

[2019 oracle code one] code one keynote

For more blog posts, see The Oracle Code One table of contents



Data Science at the Intersection of Emerging Technologies – Krik Borne

  • 30% of revenue comes from ML algorithm (recommendations)
  • Can build new products by combining emerging technologies
  • combinatorial explosion – level above exponential growth
  • Types of discovery – class discovery, correlation or causality, outlier/anomaly/novelty/surprise discovery, association/link discovery
  • Levels of analytics – Descriptive (hindsight), diagnostic (oversight), predictive (foresight), prescriptive (insight), cognitive (360 view)
  • Machine learning = mathematical algorithms that learn from experience
  • Data mining = application of ML algorithms to data
  • AI = apply ML to actions
  • Data science = application of scientific method to discovery and more
  • Analytics = products of ML and data science
  • Power of AI is augmenting what humans can do
  • 4D printing in future – change shape in real time – https://www.sculpteo.com/blog/2017/10/25/4d-printing-a-technology-coming-from-the-future/

A golden age for developers – Greg Pavlik

  • Modern apps are
    • intelligent (use M to suggest and predict))
    • cloud native
    • agile
  • Examples
    • Detect disease up to level of individual plants
    • Go thru resumes and identify best fit jobs. Career progression [both of these are scary!]
  • Cycle: data exploration, build/train model, deploy model, manage model, repeat
  • Model is only as good as the data. The data changes over time.

Fighting Diabetes with Technology – Todd Sharp

  • Traditional Monitoring
    • Monitor blood sugar throughout day. Typically done with glucose monitor with finger prink 6-12 times a day.
    • Count carbs at every meal/snack
    • Formular determines insulin needs
    • Administer insulin at every meal/snack/bedtime
  • Technology helps
    • Continuous glucose monitoring – sensor/monitor below skin. Communicate by Bluetooth/in cloud
    • Insulin pumps. Constant and on demand insulin provided below skin. Again work with smart phone and in cloud
    • Expensive
  • Missing link is counting carbs and calculating insulin
  • Created an app
    • Full mode includes insulin calculation.
    • Quick mode to just count carbs
    • Formula based on meal/time of day
    • Enter data by a picture or voice. Have to weigh portion – uses Bluetooth scale
    • Can handle raw food (apple) or packaged food (graham cracker sticks)
    • Glucose meter pairs with app via Bluetooth as well to get current value
    • With all of this, can calculate number of insulin units for meal
  • Tech
    • Progressive web app
    • Microservices
    • Oracle Cloud
    • Autonomous DB
    • Serverless
    • Micronaut
    • Materialized view
    • ML – test/train data sets

Autonomous Database for Developers – Maria Colgan

  • Many types of database (relational, graph, etc)
  • No DBA support needed
  • Showed wizard to create database. Serverless is an option
  • Automatically identifies and adds missing indexes after confirms they will improve performance
  • Elastic scaling
  • Can clone database with a wizard (with or without data)

My take

Parts of this were interesting. Others felt more like a commercial. I liked the diabetes story. The whole thing captured my attention. It felt like it didn’t fit with the others though. I also noticed a lot of people leaving immediately after Todd’s talk. So it looks like a lot of people came specifically for that. I left before the end of the Autonomous Database section. At the two hour mark of the keynote, I needed to get up!

[2019 oracle code one] CD with Docker and Java

Continuous Delivery with Docker Containers and Java: The Good, the Bad, and the Ugly

Speaker: Daniel Bryant @danielbryantuk

For more blog posts, see The Oracle Code One table of contents



General

  • “Continuous delivery is achieved when stability and speed can satisfy business demand. Discontinuous delivery occurs when stability and speed are insufficient” – Steve Smith @SteveSmithCD
  • Feedback loop
  • Choices are about tradeoffs

Good

  • Dev environment setup can be Dockerized/Containerized
  • Repeatable builds
  • Legacy technology can be sealed

Bad

  • Why is the container image 1GB for a hello world app
  • Dev/test/deploy/loop too long
  • The app runs slow/freezes on Docker

Impact of container tech on CD

  • Install Docker/container on local machine. Important to understand platform deploying to (mechanical sympathy).
  • Store container image, not jar/war
  • Test in container image
  • Container image is single binary – “Build Binaries Only Once (BBOO)”

Lessons

  • Make dev env like prod as much as possible. Use identical base image with same config.
  • Dockerfile content is super important – OS, ports, volumes, JDK
  • Talk to the sysadmin people. Their operational knowledge is invaluable. Avoids both operational and political problems
  • Don’t want JDK in production. [so what use. JRE no longer exists. Can’t use JLink if need Tomcat to run app.
  • Avoid unused Maven dependencies (so smaller]
  • BuildKit – best effort caching
  • Get app/config drift if have different dev/prod containers
  • Use sidecar containers to bundle other things
  • Toolchain may alter when go to container space.
  • Metadata is valuable. Need to know what is running where. Can store in external registry. ex: Artifactory or Nexus
  • Try to do component testing – a few services together
  • Performance – gatling, jmeter, flood.io
  • Security testing – ex: https://find-sec-bugs.github.io
  • Migrate to Java 11 for speed
  • AOT gives performance in short term and JIT in long term
  • Re test app when change any config
  • Set container memory appropriately
  • Dependency check – https://jeremylong.github.io/DependencyCheck/dependency-check-maven/
  • Docker container scanner – https://github.com/arminc/clair-scanner or https://github.com/aquasecurity/microscanner
  • Only thing worse than not using a security tool is using an unmaintained security tool

My take

Good session. The advice covered different levels of problems which was nice. The flowchart was unreadable. I think I got the gist, but it’s hard to get a complex flow on the screen. The rest was clear and I came away with a bunch of stuff to read about