[uberconf 2023] intellij dojo

Dan Hinojosa

For more, see the table of contents

Uses https://github.com/dhinojosa/intellij-dojo-workshop


  • Help > Keyboard Shortcuts PDF
  • Goal: get away from mouse
  • I tried to note both windows and mac since I use both. I followed along on Mac live
  • Presentation assistant shows shortcuts used [I used this one]
  • Key Promoter X – reminds you to use plugin [I turned this off; it was super annoying]

New projects

  • Projects typically created outside the IDE so just have to open the project
  • Open new project (or recent projects)
  • Can setup to open from command line by typing “idea .” – Open toolbox (not in IntelliJ; helps with downloading > bolt > settings > tools – shows where command line)


  • Command or alt 1 – project menu – start typing name of file to get straight to it. Arrows to go thru nav menu.
  • Command or alt 2 – bookmarks
  • shift escape – close window – ex if have bookmarks open.
  • Command or alt 3 – find window
  • Command or alt 4 – run window
  • Command or alt 5 – debug window
  • Command or alt 6 – problems window “six is to fix”
  • Command or alt 7 – structure window (outline of file)
  • Command or alt 9 – git log
  • Command or alt 0 – commit window
  • Command or alt e – recent files list
  • Command shift e – recent edit locations (within file)
  • Command or control shift F12 – maximize/restore editor

Action keys

  • Command or control shift A – all actions – shows shortcut next to it so can type name and review shortcut
  • control control – run anything within project. type “?” to see what the choice are. ex: run maven test quickly. Also shows recent commands
  • shift shift – search everywhere ex: files, options in ide, even has a calculator


  • control (or Alt windows) right/left – didn’t work for me on mac; ctrl tab lets me see tabs and pressing it repeatedly switches between them
  • ctrl F4 (was command w on my machine)

Finding items

  • command o/Ctrl N – go to class (supposed to be o for mac, but n works for me)
  • command shift o/ctrl shift n – go to file
  • command option o/ctrl option n – go to symbol
  • command/ctrl b – go to declaration
  • command/ctrl alt b – go to implementation
  • option/alt f7 – find usages
  • command/ctrl f7 – find in file

TDD Sample

  • command/ctrl n – create new – then choose what want ex: Java class. do again within class and can create test method automatically
  • F2/shift F2 – switch between problems (ex: compiler error). If no errors, says no errors found
  • alt/option enter – context sensitive actions ex: fix error, refactor
  • command/ctrl shift t – toggle between test and code under test
  • ctrl t (mac) ctrl alt shift t (win) – refactor this menu
  • command l – go to line


  • command option/control alt l – format all code
  • control alt/option o – organize imports

Selecting code blocks

  • option down/ctrl shift w increase code block selected – ex: line -> section of code -> method -> class
  • option up/ctrl w increase code block selected


  • command/ctrl delete – delete line
  • command/ctrl d – duplicate line
  • command/ctrl x – cut line
  • command/ctrl c – copy line
  • command/ctrl v paste line
  • command/ctrl shift v – paste from history; still available even after pasted
  • command/ctrl t – surround block/selection – didn’t work for me on mac
  • command option t/ctrl shift t – surround with – ex: wrap with if/try/etc

Code completion

  • pvsm – generate main method
  • postfix – write. sout or .var or the like at end of line if forgot something at beginning of line and fixes. Can add own with live templates
  • ctrl space – autocomplete
  • ctrl option/alt space – inaccessible members autocomplete; will import at same time
  • ctrl shift space – type sensitive complete – filter autocomplete based on the desired type
  • command/ctrl shift enter – complete statement – ex: add { for if statement
  • command/ctrl p – parameter info – click method and get pop up with the parameters for all overloads. Works when writing code or on filled in code
  • ctrl shift p – type info – useful on a stream to see return type. If ambiguous have to chose which expression from a list first


  • Command/ctrl shift up or down – move code up or down compared to other code


  • Ctrl Q – windows, Ctrl J – mac – pop up for docs
  • ctrl shift i win, command y – mac – pop up with source code/implementation. use right/left if multiple matches (ex: levels in hierarchy)
  • alt q windows, ctrl shift q mac – pop up with method name, press again for class. useful in long legacy code


  • Contextually – main methods, tests , folder of tests etc
  • If create file named http, will run it. Uses specified format to specify get/post, content type, etc – https://www.jetbrains.com/help/idea/http-client-in-product-code-editor.html. Good if don’t need credentials
  • ctrl shift F10 win, ctrl shirt r mac – First time, run and mark context configuration. Like staking a claim
  • shift F10 win, ctrl r mac- run last config
  • alt shift f10 win, ctrl option r mac – mark context
  • Replace d with r for debug versions
  • In debugger, trace current stream chain lets you see each step of a stream and what is there. (click three dots in debugger to see it). Choose flat mode to see everything on one screen


  • ctrl t (mac) ctrl alt shift t (win) – refactor this menu – this one includes all the other refactorings. Including obscure ones like changing a method return type
  • F5 – copy item
  • F6 – move item
  • shift F6 – rename globally
  • command/alt delete – safe delete
  • ctrl alt n – inline
  • command option/ctrl alt m – extract method
  • command option/ctrl alt v – extract variable
  • command option/ctrl alt f – extract field
  • command option/ctrl alt c – extract constant
  • command option/ctrl alt p – extract parameter


  • shift command 8/alt shift insert win – start column selection mode.
  • hold shift down and get multiple cursors at that column
  • alt/option shift click – start multicursor mode – each click gives you a cursor
  • ctrl g mac, alt j windows – next instance of word giving you a cursor for each (select method/class/etc want to match first)
  • ctrl command g mac, alt shift j win – all instances of word giving cursor for each

HTML/XML editing

Version Control

  • Command/Ctrl 0 – changes window
  • Command/Ctrl K – commit
  • Command/Ctrl t – update project
  • command/ctrl shift k – push
  • ctrl v – mac, alt ` windows – version control quick help

Random stuff

  • If reference a closure variable (ex: effectively final variable used in a lambda), variable appears in purple.
  • Presentation mode – don’t need to mess with font manually when present
  • File and Code templates – for commonly used code

Side note

Chrome has a built in QR code generator – share the link and QR is an option

My take

It was good to get practice and learn more shortcuts. Also learned I had my keymap set to mac classic (that explains why some expected shortcuts hadn’t worked; fixed it). I like the windows/mac contrasts. Felt less magical seeing it presented together. (I use both).. Good mix of hands on and watching.

[uberconf 2023] Architect’s Guide to Site Reliability Engineering

Speaker: Nathaniel Schutta


For more, see the table of contents


  • Agile – do more of what works
  • Conflicting incentives – ops – “don’t change if works”
  • Monoliths to service oriented to microservices – solves some problems and created new ones
  • SRE (site reliability engineer) – new role
  • We are good at giving something a new name and pretending have never done before. Ex: cloud computing – big pile of commute and slice of what need – ex: mainframe
  • Everything we do involve other people. Most problems are people problems, which we tend to ignore


  • Goes back to Apollo problem. First SRE was Margret Hamilton. She wanted to add error checking and did update the docs
  • Phone autocorrects on map – recalculating….
  • Traditionally systems run by system admins.
  • Now have hundreds/thousands of services
  • CORBA – facilitate communicate for disparate systems on diverse platforms. Also a good definition for microservices. EJBs too. Then SOA
  • APIs exploded because we all have smartphones/supercomputers in our pocket
  • Amazon had policy of everything being an API


  • Who page if go through 20 service. It’s clearly another team’s problem
  • How monitor
  • How debug
  • How even find services
  • We argue about definition of made up words. Ex: microservice. Nate likes definition that it can be written in two weeks. How many services can a team support? If change alot, 4-6. If stable, 15-20
  • How do we define an application?
  • Conflicting incentives – release often
  • The way we do things might be the first way we tried vs a better way.


  • What if we asked software devs to define an ops team?
  • Software engineering applied to operations
  • Did that with testing too; made more like dev
  • Replace manual tasks with automation
  • Many SREs former software engineers.
  • Helpful to understand Linux
  • Can’t reply on quarterly “Review Board”. This is a very slow quality gate. However, most orgs don’t audit gate to see if useful.
  • Goal: move fast, safely
  • Doesn’t happen in spare cycles “when have time”. Can’t be on call all the time or be doing tickets/manual work all the time.
  • Humans can’t do the same thing twice. Ex: golf

What does SRE do/consider

  • Availability
  • Stability
  • Latency
  • Performance
  • Monitoring
  • Capacity planning
  • Emergency response
  • Understand SLOs
  • Embrace/manage/mitigate risk. Risk is a continuum and a business decision
  • Short term vs long term thinking. Heroics works for a while, but isn’t sustainable. Often better to lower SLOs for a short time to come up with better solution.
  • Focus on mean time to recovery. No such thing as 100% uptime.
  • Runbook is helpful. Not everyone is an expert on the system. Even if do know, brain doesn’t work well in middle of the night or under pressure. Playbook produces 2x improvement in mean time to recovery
  • People fall to level of training, react worse when stressed.
  • Alerting. Need to know what is important/critical and when it is important. Ex: can ignore car oil change message for a bit but not for too long
  • Logging best practices. Logs tend to be nothing or repeating the same thing 10x.
  • Four golden signals – latency, traffic level, error rate, saturation
  • Automate everything; manual toil drives people out of SRE
  • Which services most important
  • Establish an error budget. Can experiment when more stable. Can’t deploy when error budget used up. Helps understand tradeoffs.
  • Production readiness reviews.
  • Get everyone on same page with what service does – dev, archs, etc. Improves understanding and can find bottlenecks
  • Checklists – quantifiable and measurable items.
  • Think about how it can fail and what happens if it does
  • Chaos engineering

Outage impact

  • What do customers expect? Used to be 5×12 – 6am-6pm M-F. Most things are 24×7 now
  • What do competitors provide? Need to do same
  • Cost – more failover is super expensive
  • When cloud goes down, it is news
  • Depends if needs redundant backup. How much venue lose than cost of being down?


  • Don’t want to make same mistakes. Learn from yours and others. Avoid them becoming a blame session
  • Outages will still happen; must learn from them so that bad thing doesn’t happen again
  • Living documents – status as the outage is happening, impact to business, root causes
  • Tactical vs long term/strategic fix
  • Action items to avoid in future
  • Cultural issues
  • Wheel of misfortune – role play disaster, practice
  • Recognize people for participating
  • Need senior management to encourage
  • Provide a retro on postmortem to improve process
  • Education – if you already understood that, we’d give you something harder to do


  • 99% – 7.2 hours a month, 14.4 minutes a day
  • 99.9% – 8.76 hours a year, 1.44 minutes a day
  • 99.99% – 4.38 minutes a month; 8.66 seconds a day
  • 99.999% – 4.38 minutes a month; 864 millis a day
  • Google K8S Engine availability is 99.5%. Can;t exceed service provider
  • SLA (service level agreement) means financial consequence of missing. Otherwise, it is a SLO
  • More to always better; can’t be infinity
  • Can tighten later; hard to losen
  • If a system exceeds their SLA, can’t rely on that. Could stop at any time.
  • Might have internal SLO that is tighter than the advertised one.
  • Everyone wants five nines until they see the cost. “If you have to ask, you can’t afford it”

Fitness functions

  • Tests to make sure architecture still does what want it to do
  • If know when breaks, can tie back to code change and fix

Next steps

  • Build an SRE team if don’t have one
  • Applications changing rapidly
  • Need to enable environment to move fast and safely
  • Must work well together

My take

Nate’s style is a ton of slides with a mostly few words/sentence on each. It’s a fun style. It also means the font size is super large and I don’t need to wear my glasses for most slides. I had to step out for a few minutes for the restroom. [I’ve been doing an excellent version hydrating!] Hard to step out, but easy to catch when came back.

[uberconf 2023] go(lang) for java developers workshop

Speaker: Ken Sipe

For more, see the table of contents



  • Normally this is a workshop. Today’s session is abridged
  • Lots in lab that aren’t in the slides/presentation
  • Labs: https://github.com/kensipe/go-labs
  • Solutions: https://github.com/codementor/wman


  • Go Lang only for search. Call it Go in talking
  • Google made Go in 2009 and started using in 2010
  • Killer app – advanced cloud/k8s
  • 1.0 released in 2012
  • Release every six months
  • Can run online – https://go.dev/tour/welcome/1
  • VSCode has good plugin. IntelliJ makes a Go IDE – GoLand. IntelliJ plugin for Go not same as GoLand

Value proposition

  • Ease to use – productivity
  • Efficient execution
  • Type safe
  • Latency free garbage collection
  • Fast compilation
  • Native binary, but run on multiple platforms

More about Go

  • Some inspiration from C but not derived from c family
  • Language simplicity – no inheritance/generics/assertions/method overload/classes
  • Implement interface
  • Inference assignment
  • Have structs, but not OO


  • format is defined. {} must be positioned right. { must be on same line as predecessor
  • No semicolons

Differences from Java

  • No classes
  • Main doesn’t have ceremony – func main
  • In Java, the project contains the src tree. In Go, you clone the whole project into your src tree (GOPATH). In later versions of Go, can scatter if want.
  • Functions in files – less of a conventions
  • return used a lot more than in Java – want to fail fast/get out of method as quickly as possible
  • Naming controls behavior. name is private; Name is public

Go commands and files

  • go mod init – creates a go project in the current directory (assuming in GOPATH)
  • go mod init github.com/user/proj – creates a new go module
  • Creates go.mod file listing version number by default
  • go.mod lists required dependencies once add them
  • go.sum – checksum for dependencies
  • go doc – command line help. ex: go doc fmt or go doc.fmt.Println
  • many linters as options
  • go mod verify – checks checksums
  • go mod tidy – remove any unused dependencies

Hello World

package main

import "fmt"

func main() {
	fmt.Println("Hello World")


  • Can import one at a time or a list – like namespaces
  • Built in packages: https://pkg.go.dev/std
  • Reusable packages: http://awesome-go.com
  • Ken makes three sections; by likelihood of changing dependencies listed later and alphabetized by group. GoLand handles this ordering.
import "fmt"
import "net/http"


import (


  • bool
  • string
  • int, int8, int16, int32, int64
  • uint, unit8, uint16, uint32, uint64, uintptr
  • byte (alias for uint8)
  • rune (alias for int32)
  • float32, float64
  • complex64, complex128
  • Array
  • Slice – initially, think of as a way of getting to an array. Can pass part of an array via a slice. Window view onto array.
  • Struct – create own structure
  • Pointer
  • Function
  • Interface
  • Map
  • Channel – stream of things, can be bounded or unbounded, can add events to channel
  • if just use “int”, get default for your platform
  • defining size matters for certain apps


  • var name string
  • name = “value”
  • var a, b, c int
  • var name = “hello”
  • var a, b, c = 1, 2, 3
  • var a, b = 1, true – don’t mix types on one line
  • Common to have terse variable names when very small scope
  • Leave out time if can be inferred
  • message := “hello” – most common way for creating a variable, can shadow variable if exists in different scope
  • a, b, c := 1, 2, 3
  • x, y := FunctionReturningTwoThings()
  • Will not compile if define variable that is not used
  • _, y := FunctionReturningTwoThingsWhereDoNotCareAboutFirstOne()

Pass by reference

  • Pass by value by default. If want pass by reference, need to pass a pointer
  • foo(&a) – to pass pointer
  • fun foo(count *int) – takes pointer
  • *count – use thing pointer preferences (ex: int)
  • count – gives you actual pointer
  • Strongly typed – can’t pass nil if has a declared return type. Can if pointer

User Defined types

  • type MyType string – alias to an existing type. Can add functions to your type.
type MyType struct {
  name string
  value string

var mine = MyType { "n", "v" }
var longer = MyType { name: "n", value: "v" }
var evenLonger = MyType{}
eventLonger.name = "n"
  • When use longer format to create, order doesn’t matter when passing in values and can leave some out.


const (
 PI = 3.4
 other1 = iota
 other2 = iota

iota is successive integers where don’t care about the numbers


myMap := map[string]int {
  "n": 4,


Last comma needed to compile. This avoids changing lines in version control that weren’t affected by the change.


  • os.Args – to get args passed to main
  • fmt.Println(a, b, c)
  • fun Mine(type string) string – return one string
  • fun Mine(type string) (string, string) – return two strings
  • return “a”, “b” – return two things
  • fun Mine(name … string) – takes a slice of strings; can call like varargs in Java

Can use variables for return. If don’t set all return values, “return” will fail. (Ok to use nil)

func Mine() (x string, y string) {
  x = "x"
  y = "y"


  • Function only accessible on a type
func (x MyType) MethodName() {
var m = MyType{}


  • uses duck typing – if method has signature of interface, it is that interface
  • interface{} – no functions so everything implements

My take

Good intro. I was puzzled at the beginning about scope. I thought it was a talk but he said workshop. Then the instructions about creating a key were there. Then it was a talk. Which is what I was expecting. It would have been clearer to not include “workshop” in the title slide to match both the abstract and session. Avoids that confusion. I do like the lab was available for “later”. The references to “we will cover that later” with 20 minutes left felt like false promises.

The actual material and flow was great. I learned a lot and the callouts for what is different in Java was helpful. The examples were good for learning. I’m happy with the session and glad I attended. I just wish it was designed to be a 90 minute presentation with “see here for full” rather than trying to shoehorn something clearly much longer into 90 minutes.

He went a little over. I stopped blogging at the official end time because the rest was flying through a lot of the remaining slides too fast to follow, let alone understand/type.