[2019 oracle code one] DevOps Theory vs Practice

DevOps Theory vs Practice: A Song of Ice and Tire Fire

Speakers: Viktor Gamov (@gamussa) & Baruch Sadogursky (@jbarauch)

Deck: https://jfrog.com/shownotes/

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

Humor from imaginary thought leader (make sure you enjoy sarcasm in this section)

  • “Everybody’s software must be releasable at absolutely any time” – even if drunk?
  • “Everyone must have 100% test automation” – even if release 3-4 times a user to 2-3 users. cost makes sense
  • “We do Continuous Security well” – even if hire security person so have someone to blame
  • “Your greatest threat is an outage. Not an employee; just trust your employees” – even if CIO leaves bus with all data.
  • “VMs are the enemy of DevOps. This is where you must focus your innovation, Docker and Kubernetes” – Even for app just migrated from mainframe and not container ready
  • “You are a beautiful unique snowflake as are your problems. No vendor could possibly understand them.” So should invent own framework b/c written by other people.
  • “Our company is based in SF b/c that’s where the best engineers are”. Expensive b/c rent high

Four Questions

  • Is org/team ready to adopt new tech?
  • Is it even good tech? What do you know besides the demo? Where is it on Gartner’s hype curve? Thoughtworks Technology Radar – https://www.thoughtworks.com/radar
  • What problem do I solve by using this tech? What problem are you trying to solve? Not resume driven development
  • Will solving this problem help my organization?

Random notes

  • You are not NetFlix. Running chaos monkey on your network of ATM machines not a good idea.
  • Master Excel or Google Spreadsheets

Maturity models

  • Think about capabilities when trying to accelerate software development, not maturity models
  • Bad maturity models are bad
  • Bad models – goal driven. Get to goal and then are “done” improving, one size fits all from book, checkboxes for tools, write and forget
  • Good models – process driven, focus on outcomes
  • Components – evaluation factors (ex: is there a CI process), scoring methodology (is there partial credit), self assessment vs 3rd party assessment (how know if good process), progress tracking (of evolution), visualization (to show to people with different levels of involvement)
  • Different levels of detail for capabilities
  • Account for priorities of different teams – engineering, ops, business
  • Only use primary colors
  • Involve team in involving model definition and assessment
  • Partner with forward looking teams
  • Evolve model over time

My take

The intro was hilarious. The content was good as well 🙂

[2019 oracle code one] mastering regular expressions

Mastering Regular Expressions (^.*$)(?#everything) You Should Know

Speakers: Fernando Babadopulos @babadopulos

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


  • Invented in 1951
  • Popularized in 70’s with vi/lex/sed/awk/expr
  • In 80’s Perl included advanced regex
  • Java 1.4 – added regex


  • Used for a spam filter before AI started detecting spam
  • Not just for developers. Can do lots of things in text editor


  • Eager – starts with leftmost match and first match is good enough.

Regex Examples

  • /Java/ – match first string “Java”
  • /database/g/ – match all instances of string “database” (different syntax than for Java. Typing without the / from now one)
  • .* – match everything (or nothing) – as much as can because eager
  • [dl]ate – character class matching d or l (followed by ate)
  • a[^p] – negated character class. No “p” after “a”
  • database[0-9]\. – range of database0. to database9.
  • \d\d.\d\d – Two digits, any character and two more digits. Probably not what you want. Works if have valid data. But will also match 15624. Use what want ex: [:h] instead of dot. (Or escape the dot if want a period)
  • ^(.*),(.*) – Want first two fields of a CSV. [unless have commas inside field with quotes]. Backtracks a lot though because consumes entire string and backtracks one character at a time until gets to a comma. Then backtracks more. Better to write [^,] than dot so express what actually want.
  • ^([^,]*),[^,]*)$ – match exactly two field [Unless have commas within quotes for an element]
  • ^[a-z]*$ – empty file or only lower case letters
  • get|set – match either string
  • \bget|set\b – matches words that end with get or start with set – not what intended
  • \b(get|set)\b – only match words get or set since checking for boundary (space, tab, etc)
  • Jan(uary)? – matches Jan or January
  • a{0,10} – 0-10 a’s
  • a{10} – exactly 10 a’s
  • a{0,} – zero or more a’s
  • a{1,} – at least one a’s
  • Java(?=Script) – positive lookahead – Java followed by Script
  • Java(?!Script) – negative lookahead – Java not followed by Script


  • \( -escape paren
  • \d – shorthand for digit
  • \s – shorthand for whitespace
  • \w – shorthand for word
  • \\ – slash


  • Avoid . – use characters want or negative character class.
  • Use anchors (^ and $) wherever possible.


  • Type regex
  • Gives explanation of regex typed
  • Can set flags ex: global
  • Area for test string to see what matches
  • Has a code generator so can get regex with proper Java escaping
  • Has debugger – can step through the parts of the reg ex and see what matches at each step. It also shows backtracking. This seems like a good way to see the efficiency of a regex as well. [Cool!]

Other URLs:

https://www.regular-expressions.info – tutorial

https://regexper.com – create graphs

My take

I enjoyed the debate (and then vote) on how to pronounce regex before the talk started! Half of the audience raised their hands for liking regular expressions. Biased crowd of course. The room was awkward and the lecturn hid part of the screen. I like that he showed a lot of examples and the execution graph. I really like the debugger on regex101. Learning that was worth attending the talk on its own! As was the regexper graph site

[2019 oracle code one] java concurrency

Java Concurrency, A(nother) Peak Under the Hood

Speakers: David Buck (Oracle) – @DavidBuckJP

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

Multi threaded code use cases

  • GUIs
  • Libraries
  • Batch Processing
  • Worst case: writing multi-threaded code but don’t know you are


  • Race conditions
  • Heisenbugs/observer problem – occur in Prod (or locally), but disappear in debugger


  • Java memory model
  • synchronized keyword
  • java.util.concurrent

Memory model

  • What guarantees do you have that writes in one thread are available to another thread?
    • Local variables safe
    • Static variables/instance variables can introduce concurrency problems
    • JIT compiler can change order things are done (vs the order you code them in)
    • If optimizing compiler sees a = 1 and a=a+1, compiler will just initialize a to 2.
    • Out of order execution – hardware can execute out of order to improve performance
  • Clartify what multithreaded behavior developers may depend on. Limits what types of optimizations the runtime can do
  • Spec: https://docs.oracle.com/javase/specs/jls/se13/html/jls-17.html

Things Java Protects us from

  • Testing on Raspberry Pi because ARM so can see problems that don’t occur on Intel chips
  • memory barrier/fence
  • prevents reordering before before/after fence. How do to this varies by processor./tool chain. Need to set two – one on read and one on write to guarantee behavior for testing.
  • Types: store-store, store-load, load-store, load-load


  • As in physics, no single “correct” timelines
  • Observed order of events depends on frame of reference
  • Each core can have slightly different view of memory
  • This means core files aren’t 100% accurate

Changes to memory model

  • Originally only dealt with synchronized – mutual exclusion and happened-before. Volatile was defined but just about visibility
  • This was a problem because volatile didn’t enforce happened-before and final values could change.
  • Java 5 adopted Doug Lea’s open source APIs (JSR-166)
  • JSR-133 – ensured volatile does establish happens-before and final values will never changed
  • Volatile != atomic
  • id++ still not thread safe on a volatile field. Can use synchronized to fix
  • In original memory model, 64-bit numbers (longs and doubles) not updated atomically

Practical advice

  • Use highest level construct available. java.util.concurrency > synchronized/wait/notify. Last choice is volatile/final
  • Don’t roll your own. Even Doug Lea didn’t get it perfect
  • Java 8 – Lambdas/streams – high level
  • Java 9 – Var handles – lower level than volatile/final. Alllows value to be volatile only when we want it to be. Explicit fence/acquire/release. This was introduced for use cases sun.misc.Unsafe used to deal with.

My take

This was really interesting. It was like a peek behind the curtain! My only complain is that dark red text on a black background is hard to read. Luckily there wasn’t much of it and it was obvious what was being “emphasized” in red. Also, I liked the demos!