The Curious Engineer

All blogs / Software / engineering practice

Jessitron

jessitron.com

Jessica Kerr (aka jessitron) is a developer and symmathecist. Here are my accomplishments.

Software / engineering practiceAI / MLDevOps / SRE / infrastructureEssays / personal

’15’20’25
Posts
651 from 5 Sep 2011 to 14 Oct 2026
Posting
monthly (13 in the last year)
Kind
personal blog
Feed
https://jessitron.com/feed/

2026 11

  1. Sharing Theories with Agents
  2. When individualism worked
  3. Who are we Now?
  4. Symmathesy and AI with Kent Beck
  5. Verum Factum and the Creator’s Confidence
  6. What is it like to be you?
  7. Span or Attribute? in OpenTelemetry custom instrumentation
  8. Communication is hard, but sometimes I can fix it.
  9. Adding Correctness Conditions to Code Changes
  10. Working with AI: Do Things Right
  11. Working with AI: How does it Know?

2025 11

  1. Speak So They Can Hear You
  2. What is special about MCP?
  3. Ritual & its Consequences: book summary
  4. When efficiency isn’t wasteful
  5. Fixing Without Understanding
  6. Augmented Coding: Better with Principles
  7. Augmented Coding: an Experience Report
  8. Software development is…
  9. The world is terrible and great
  10. Cascading OKRs: We can do Better
  11. Hitting OKRs vs Doing Your Job

2024 16

  1. OKRs for Evil and Good
  2. Productivity v Impact
  3. Why is every startup’s website so darn useless?
  4. Command vs Control
  5. Communication Structures in a Growing Organization
  6. Who turns software into money? GTM
  7. How hard can it be to buy software?
  8. I can write the code. Getting something done is another matter.
  9. Going Deep on Gamification
  10. Bridges Summit
  11. Stupid bash tricks: a self-updating script
  12. Working with others is different from working.
  13. Fear and participation
  14. talk: Experimenting in Sociotechnical Systems
  15. Double Loop of Value
  16. Being the Best

2023 22

  1. Sending OTLP Logs from JavaScript
  2. OpenTelemetry in a script tag
  3. Enabling Gaps
  4. Software is Complicated, Given Enough Time
  5. Working Skillfully in Complexity (for VDDD)
  6. Testing an OpenTelemetry Collector deployed as a Daemonset in Kubernetes
  7. A Developer’s Starting Point for Integrating with LLMs
  8. Gamification: we can do better.
  9. Observability for Speed and Flow
  10. Participation without complicity
  11. No More Feedback (book summary)
  12. Why no traces? Traceflags 00 edition
  13. Accountability for Effective Teams
  14. Alignment gets expensive. Don’t skimp on it.
  15. Using ChatGPT in Anger (not real anger)
  16. Setting up ALB Access Logs in EKS using Terraform
  17. when the world feels wrong
  18. Error: missing ‘x-honeycomb-dataset’ header
  19. How to search for requests (vs all events) in Honeycomb
  20. bash: get the directory this script is in
  21. Book Review: Software Design By Example
  22. Resilience and Waste in Software Teams

2022 14

  1. Velocity defeats itself. Get acceleration instead
  2. import { utility} from StackOverflow
  3. Make https work on gRPC in Rust: load a root certificate into the TLS config
  4. Why we use kubernetes
  5. CSS for giving the extra width to the thing in the middle
  6. The Viable Systems Model, and where my team fits
  7. Run the OpenTelemetry Collector in Kubernetes for Front-End Tracing
  8. Why we have containers
  9. Keep your experiments separate
  10. Five Measurements You Should Make and Then Ignore (Plus One to Watch Intently)
  11. Every SaaS Integration needs an Upstream Point of Contact
  12. startSpan vs startActiveSpan in OpenTelemetry JS
  13. To share the work, share the decisions
  14. Starter Elm app that deploys on Netlify

2021 19

  1. Copy the Questions, not the Answers
  2. Tracing makes a bug easy to spot
  3. Software development pushes us to get better as people
  4. Symmathesies follow a power law, not a bell curve
  5. Product teams own capabilities, not (only) code.
  6. Minimum path to a Jupyter Notebook in VSCode
  7. What is this “product” you speak of?
  8. Run an OpenTelemetry Collector locally in Docker
  9. Better coordination, or better software?
  10. Project to Product asks more of our software, and more of us
  11. Three Easy Ways to Use Distributed Traces
  12. the Enterprise eats Software
  13. Software Design: Beyond Boxes and Lines
  14. A high-resilience org chart
  15. Systems Thinking for Developers
  16. yargs –do-things-right
  17. Those pesky pull request reviews
  18. One key trick to becoming a wizard developer
  19. When costs are nonlinear, keep it small.

2020 80

  1. 10x developer: work->knowledge->work
  2. 10x engineers: the Purple Developer
  3. Nonlinear increases in complexity make unification excruciating.
  4. UX request: Tell, don’t hide
  5. Every level is different
  6. To grow, yet not to control
  7. Being a responsible subsystem
  8. Reaction to the Tool
  9. Control from within
  10. Clockwork to Complexity: scale in time and software
  11. Software teams are like Executive Teams
  12. Code is a coastline
  13. Aircraft Carriers and Paper Airplanes
  14. Preserve, no. Sustain, yes
  15. Stupidity can be a plus in corporations — but not in software development.
  16. Disincentives are more powerful than incentives
  17. Back when software was a craft
  18. Principles of Collaborative Automation
  19. Grow to where we’re going
  20. Define roles by what each person increasingly knows
  21. The visible lines of division are not the meaningful ones
  22. The service you build doesn’t do a thing. It participates in a thing.
  23. Spring and JPA: use custom value types inside entities with a custom converter
  24. Fuzzy translucent background behind text in CSS
  25. motivate/enable
  26. skills v. practices
  27. talk: Shaving the Golden Yak
  28. Software development is like geriatrics
  29. Popper’s Three Worlds
  30. Developing software teaches us to design interfaces.
  31. Spring Boot log levels for development
  32. “Just” don’t
  33. Development as World Exploration
  34. Podcast: the Changelog
  35. I turned on Spring Security and my POSTs don’t work anymore
  36. Spring Security for h2-console
  37. What functional programming and secure code have in common
  38. Developer tools: extend your reach (with some work)
  39. Adding custom fields to Honeycomb traces in Rails by writing a Rack middleware
  40. Jessitron’s favorite git aliases
  41. Develop in Docker: Node.js, Express, & PostgreSQL on Heroku
  42. Honeycomb in Rails with separate dev and production events
  43. Honeycomb in Rails without hard-coding the API key
  44. Read a file with promises in TypeScript on Node
  45. Leverage as baggage
  46. Everything is terrible, especially software
  47. Control doesn’t mean you know what’s going to happen
  48. One Secret to Quality Software
  49. PowerShell equivalent of find
  50. Run Alloy on Windows in Docker
  51. Measuring effort gets you effort
  52. Subtasks vs Capabilities
  53. “Software” isn’t a thing
  54. Certainty as blindness
  55. I will not install your language tools
  56. Complication for the win
  57. PowerShell for `rm -rf`
  58. How will you collaborate?
  59. Keynote: Designing Change
  60. What makes a dependency dependable?
  61. No Roadmaps for Worldbringers
  62. Landing Zones, Long-term Desires, and Impossible Dreams
  63. PowerShell equivalent of ack
  64. Flow of what?
  65. Not about me
  66. Smaller pieces, lower pain
  67. Great software teaches
  68. Understanding, inside and out
  69. illusions of commonsense perception
  70. Capturing the World in Software
  71. Definition of DevOps
  72. Taking care of code … more and more code
  73. Fun with Docker: “Release file… is not valid yet”
  74. I don’t want the best
  75. Avoid Specificity in Expectations
  76. Go toward uncertainty
  77. Reducing WIP in laundry and code
  78. Games or gaming, Work or working
  79. Waste, fast and slow
  80. Open your eyes to the nonsense

2019 96

  1. A Christmas Adventure
  2. Smarter dishwasher, smarter cook
  3. How can we develop and operate increasingly useful software?
  4. Do things right in VSCode
  5. Basements and galleries
  6. Rebase on the World: personal shell choice
  7. Increase capacity, move slower
  8. Talk: TypeScript for Enterprise Developers
  9. Game science, programming science
  10. Work with the business, not for it
  11. 4 Terrible Ways (and 4 Better Ways) to pacify TypeScript
  12. Line endings in git
  13. Keynote: Collective Problem Solving in Music, Science, Art, and Software
  14. Layers in software: from data to value
  15. Development aesthetic: experiments
  16. This verbosity makes me happy
  17. Morning Stance
  18. Developer aesthetic: a command line
  19. Don’t build systems. Build subsystems.
  20. Nested learning loops at Netflix
  21. Don’t just keep trying; report your limits
  22. Stick with “good enough,” until it isn’t
  23. Rebase on the World
  24. Library vs service: who controls change?
  25. From complicated to complex
  26. A lot of rules
  27. In defense of rationality and dynamic programming
  28. Tools -> capabilities -> acclaim
  29. Safety and Progress
  30. Moving beyond simplicity
  31. Learning as becoming
  32. Don’t know. Find out.
  33. direct aims, broad interests
  34. Developers are system changers
  35. Regret
  36. To scale it up, smooth it out
  37. skills and/or understanding
  38. Increasing potential as a specific output of flow
  39. Closed games vs Open Games
  40. Closing the feedback loop from the customer
  41. Generativity
  42. The artifact and the process
  43. Every action has two results (Erlang edition)
  44. Victory at life
  45. Keynote: From Puzzles to Products
  46. An old idea in a new context is new.
  47. Give me feedback that is qualitative, broad, and random
  48. Progress in Learning
  49. Let’s reason about behavior
  50. Other people’s messes
  51. Mostly we orient
  52. Brains and eyes: hierarchies in vision
  53. Rules are not easy
  54. Human, or Person
  55. Why is CSS a thing?
  56. Implementing all the interfaces
  57. Rules in context: D&D edition
  58. These are not the only options. Wineglass edition
  59. Zooming in and out, for software and love
  60. Certainty, Uncertainty, or the worst of both
  61. For cleaner code, write ugly code
  62. The next architecture book you must read
  63. When the db is the interface
  64. Inertia in the interface
  65. Soft, or hard like mud
  66. Knowledge resides in teams
  67. Feature interaction
  68. Teams are like bread
  69. Develop before define
  70. When time gets tight, we make it tighter.
  71. Domain-specific laws
  72. From Puzzles to Product
  73. A definition of play, and how to live
  74. Correctness vs Change
  75. Change at different timescales
  76. Inner coherence vs usefulness
  77. Tiny dramas, tiny deploys
  78. Reasons, heuristics, and revealed intentions
  79. Designing Change vs Change Management
  80. Never and Always mean “right now”
  81. Action is a process. Reasons matter.
  82. Respond to input? No, we create it
  83. Reductionism with Command and Control
  84. Probability Spaces as reality
  85. One skill is not enough
  86. Adding qualities to systems
  87. How religion is important
  88. Five levels of learning
  89. Design by implementation
  90. Distance outside of maps
  91. this is not the beginning
  92. Predictability is hard, surprises are everywhere
  93. Mission Statement
  94. Strong Opinions Strongly Overrated
  95. Principles of Collaborative Automation
  96. Open Source needs Open Source companies.

2018 31

  1. CSS Positioning: a summary
  2. Growth Loops: circular causality is real
  3. Your Goals Are Holding You Back
  4. Shared Values are Overrated
  5. Things that are hard: trivial POST request from the browser
  6. Mutual Purpose and Agreed-Upon Methods
  7. Symmathecist (n)
  8. How I broke (and fixed) docs.atomist.com
  9. Advancing the bridge
  10. Ascendency
  11. Reading: Ecology, the Ascendent Perspective
  12. Align the stars (programmatically)
  13. REdeploy (for the first time)
  14. References
  15. Systems and context at THAT Conference
  16. When knowledge is the limiting factor
  17. Which came first, the chicken or the egg?
  18. Reading: Why Information Grows
  19. Do Things Right with TypeScript
  20. Do Things Right with npm install
  21. Kubernetes is like a dishwasher
  22. the future of software: complexity
  23. Get happy developers to do what you want
  24. learning to learn
  25. shared intentions: leveling up at helping
  26. Collective problem solving in music, art, science, and software
  27. Horizonal goals
  28. Does caring scale?
  29. Understanding code under change
  30. a thousand small problems
  31. Understanding Promises in JavaScript (with yarn and Legos)

2017 41

  1. a reference to Deference
  2. Deference or Collaboration: pick one.
  3. Automation story: GraphQL schema deployment
  4. Deliberate impermanence
  5. Why does it work?
  6. Not “why”
  7. smaller steps are the best steps
  8. Reference: Typescript asynchronous sleep that returns a promise
  9. Folding Tradeoff Space
  10. nope, can’t do everything
  11. can’t spend all day on self care
  12. Effective Use of Slack
  13. don’t make me think about style
  14. Shaping our Tools to the Flow of Conversation: Issue Creation
  15. Dictionary Objects in JavaScript and TypeScript
  16. the sweet spot: Local Automation
  17. Migrating some services from AWS to Pivotal Web Services
  18. personal automation example: deleting a local maven artifact
  19. See also: Diversity is not a magic pill
  20. The Golden Yak
  21. Stupid mocha stupid error
  22. The Royal Yak
  23. Trim Yaks
  24. The Imperial Yaks
  25. The Attack Yak
  26. A Taxonomy of Yak Shaving
  27. Hyperproductive development
  28. Video: Automating at a Higher Level with Atomist
  29. Clutter
  30. time-dependent rate phenomenon
  31. Code and Coders: components of the sociotechnical system
  32. The Architects Below
  33. a Rug story: adding test cases
  34. Reuse
  35. Correctness
  36. Scala Maven rugs
  37. Dependencies
  38. It’s Atomist Time
  39. Today’s Rug: maven executable jar
  40. Today’s Rug: maven executable jar
  41. It’s Atomist Time!

2016 13

  1. Using Rug with Elm
  2. Talk: Adventures in Elm
  3. changing systems
  4. Areas of responsibility
  5. Provenance and causality in distributed systems
  6. Stepping Stones
  7. Harder and better (slides)
  8. Tradeoffs in Coordination Among Teams
  9. Haydn or Beethoven
  10. distributed systems in a band
  11. Good news, bad news
  12. Property Testing in Elm
  13. Scaling Intelligence

2015 43

  1. Key signatures in piano music: the underlying technology
  2. Talk: Contracts as Types
  3. Getting off the ground in Elm: project setup
  4. Overcome the obstacle, or remove it?
  5. The Emperor has no clothes: Bad actors in tech
  6. ElixirConf keynote: Elixir for the world
  7. This was not OK (regrets)
  8. Functional principles come together in GraphQL at React Rally
  9. An Opening Example of Elm: building HTML by parsing parameters
  10. Data-in, Data-out
  11. Event-driven philosophy
  12. Ultratestable Coding Style
  13. Patterns and details
  14. make it small in importance in relation to the life of the surrounding world
  15. git: handy alias to find the repository root
  16. Teamwork by Design
  17. Fitting in v. Belonging
  18. Data v Awareness
  19. The Quality Wheel
  20. Isolate Failure Domains with PFWF
  21. Your Code as a Crime Scene: book review
  22. Post-agile: microservices and heads-up development
  23. Charting team course with a Seamap
  24. Today im getting my bangs dyed pink after the
  25. Looking for work
  26. Philly ETE, Design in the small
  27. Before balance, separation.
  28. Central vs Distributed Decisions
  29. Moving the Dot
  30. Gaining new superpowers
  31. Estimates and Our Brain
  32. Responsiveness over Control
  33. the New User Interface
  34. Microservices, Microbusinesses
  35. Fun with Optional Typing: cheap mocking
  36. Cropping a bunch of pictures to the same dimensions
  37. Nature vs Nurture vs Now
  38. Application vs. Reference Data
  39. Fun with Optional Typing: narrowing errors
  40. Readable, or reason-aboutable?
  41. Spring cleaning of git branches
  42. Special Snowflakes
  43. Systems Thinking about WIT

2014 57

  1. Accidental vs Deliberate Context
  2. My First Leiningen Template
  3. Dancing With Systems – The Donella Meadows Institute
  4. Programs v Software
  5. Learning to program? It’s time for Pairing with Bunny!
  6. HDFS Capacity
  7. Logs are like onions
  8. Contingencies
  9. A victory for abstraction, re-use, and small libraries
  10. REST as a debugging strategy
  11. Software is a tree
  12. Property tests don’t have to be generative
  13. Repeating commands in bash: per line, per word, and xargs
  14. A monadically built generator
  15. Talk: Concurrency Options on the JVM
  16. TDD with generative testing: an example in Ruby
  17. TDD is Dead! Long Live TDD!
  18. The power of embedded developers
  19. May I please have inlining for small dependencies?
  20. Quick reference: monads and test.check generators
  21. STLCodeCast, and a bit of Functional Programming in Java 8
  22. Property Based Testing for Better Code
  23. Stacking responsibilities
  24. Printing the HTTP status code in curl
  25. Testing akka actor termination
  26. A suggestion for testing style in Clojure
  27. GOTO Amsterdam: Respect the past, renew the present
  28. How to succeed without knowing how to succeed
  29. Data Flows One Way
  30. Limitations of Abstraction, and the Code+Coder symbiosis
  31. Declarative style in Java
  32. Highway Speeds
  33. Left to right, top to bottom
  34. You get to a point where you can feel like you are
  35. Work to Rule
  36. Work To Rule
  37. Tools
  38. Weakness and Vulnerability
  39. Weakness and Vulnerability
  40. Unreachable Stars
  41. Testing in Akka: sneaky automatic restarts
  42. Personal interfaces
  43. Personal interfaces
  44. Modularity in Scala: Isolation of dependencies
  45. Where is the Nanny?
  46. When OO and FP meet: returning the same type
  47. Property-based testing of higher-order functions
  48. Abstractions over Threads in Java and Scala
  49. ForkJoinPool: the Other ExecutorService
  50. Scala: the global ExecutionContext makes your life easier
  51. Choosing an ExecutorService
  52. Fun with Pool-Induced Deadlock
  53. Star Trek and Computer Science
  54. Libraries and Frameworks
  55. Removing files from git
  56. Why 2
  57. Testing akka: turn on debug

2013 59

  1. JVM Threads, ???, and Open Source
  2. Talk: Functional Principles for OO Developers (Ruby edition)
  3. Talk: When code reacts to data
  4. Trains within trains
  5. Narratives
  6. From lists to trains to functors
  7. git: I want my stash back
  8. Plan backwards, look forward
  9. Looking across the lines
  10. Git: Checkout multiple branches at the same time
  11. Data Exposure and Encapsulation
  12. Evolution of a developer
  13. Tools vs Self-restraint, and a Dystopian vision of FP
  14. A realistic use case for applicative functors
  15. Converting from svn to git: salvaging local branches
  16. Idempotence in math and computing
  17. Def and Val in Scala constructors
  18. Program relativity: F = d*c^2
  19. Special Relativity finally makes sense
  20. Why Aren’t There More Women Programmers
  21. Equations
  22. From Mario Kart to Version Control
  23. Finding and removing large files in git history
  24. Converting from svn to git
  25. From kicking off shoes to event sourcing
  26. A trick for deterministic testing of random behavior
  27. Abstractions in adulthood
  28. What, or how. Not both.
  29. Aqueductron – toying with dataflow in Ruby
  30. Pragmatism
  31. What’s dirtier than comments? Exceptions!
  32. Jen Myers Tumblings: Three words
  33. What FP taught me about OO: Liskov Substitution Principle explained
  34. Twisting the rules of logic in our code
  35. Behaviour vs Properties
  36. The Silver Pill
  37. Two Models of Computation: or, Why I’m Switching Trains
  38. Spiders
  39. Formal v Informal Structure
  40. Evaluating the Value of Code
  41. Every object you own is another claim on your time
  42. Property-based testing: what is it?
  43. Diagramming trick: pointing at text in Omnigraffle
  44. Scala: when is a val not a val?
  45. fittest vs fit enough
  46. Dataflow in Ruby
  47. Passing functions in Ruby: harder than it looks
  48. Come, Come, Commala: My husband’s excellent facebook status right now: Just got a message…
  49. Declarative management
  50. Unstructured teams
  51. Welcome All the People
  52. Baggage makes your life easier, and also crappier
  53. Scala: talking about yourself
  54. Jab hook cross
  55. True in UNIX, true in Functional Programming
  56. boundaries for freedom
  57. Mmmm bah
  58. From imperative to data flow to functional style
  59. Geeks, Freaks, Nerds, & Programmers

2012 113

  1. Context
  2. Jessitron
  3. TFS and Git: a comparison
  4. Git, the many parts: five categories of files
  5. Historical reasons
  6. Historical reasons
  7. On order and overhead
  8. We are all monsters
  9. The invisible hand that isn’t there
  10. Causality: tougher than it looks, but we can take it on
  11. Networking
  12. Many weapons against one Big Ball of Mud
  13. Pivot
  14. Scala: when you wish that Seq was a List
  15. A speaking experience
  16. Footnote
  17. Control limits potential: Internet edition
  18. sandboxed
  19. Imagination first
  20. So you want to be a programmer
  21. Jen Myers Tumblings: How to be awesome
  22. The chicken and the egg both come first
  23. Git Rebase inside IntelliJ IDEA
  24. Duck typing is like the force
  25. Why and how
  26. Sniffing traffic between my app and local CouchDB
  27. true in Undeath
  28. relationships
  29. we don’t know where we are going
  30. This is not OK
  31. Confessions of a woman in tech
  32. RNA vs DNA: tradeoffs
  33. comfort
  34. Functors: What the funk for?
  35. When is code data, and when is it code?
  36. What is flatMap?
  37. waste not, grow not
  38. mastery
  39. we do not exist in isolation
  40. Abstraction goes both ways
  41. perspective
  42. Iterators in Scala: glory and danger
  43. def in Scala: equals sign or no equals sign?
  44. Git: The Good Parts – history is written by the victors
  45. better than monkeys
  46. the one and the two, and the third in between
  47. Git: The Good Parts – moving files between trees
  48. Breaking stuff apart
  49. I played clarinet for years but i was never
  50. Shape your mind
  51. Unfinished a picture remains alive dangerous a
  52. When a programmer learns about a cool new tool he
  53. Bus drivers work only in strongly typed languages
  54. Your code is your team
  55. Control limits potential, part 2
  56. Advancement through operations
  57. The opposite of simple is not complex
  58. Brains, computers, and problem solutions
  59. A third way
  60. Get the whole story
  61. Why is code so much easier than people?
  62. This tumblr is not meaningful
  63. Amoeba Code
  64. Victory through failure
  65. Control limits potential
  66. Don Quixote was an Enterprise Architect
  67. What makes a functional programmer?
  68. Database versioning, Android style
  69. using checkstyle in gradle
  70. When a git branch goes bad
  71. Git Happens: the movie
  72. Real-life git-flow
  73. Choices with def and val in Scala
  74. Mental revolution
  75. in which I exhibit sexism in the same tweet that I complain about it
  76. Site search sanity
  77. the skinny on git-flow
  78. Saint Louis, Technology City Extraordinaire
  79. Expect to fly
  80. Android: Confirmation Dialog
  81. Connecting Java Projects in Gradle
  82. Why Functional Matters: Your white board will never be the same
  83. Return of the Stateful Client
  84. F# made Java easier today
  85. Oh, IntelliJ IDEA, how I miss you
  86. Testing Google Analytics locally
  87. services on a Mac
  88. configuring soundex in elasticsearch
  89. elasticsearch: first things first
  90. Inserting data into elasticsearch over HTTP: a breakdown
  91. Lessons from SICP: what is iterative programming?
  92. Excluding manual tests in Gradle
  93. Continuation Style Without the Fugly
  94. Bring the data to the code, or the code to the data?
  95. The confluence of FP and OO
  96. One level deeper
  97. Git: retroactive branching
  98. VCS as Biographer
  99. Static Methods Are Your Friend
  100. Abstractions in methodologies
  101. Strong Typing in Java: a religious argument
  102. Video review: Java.next
  103. Why programming is awesome
  104. F# Snippet: sequence partitioning
  105. Daily Javascript: input arguments to scripts
  106. Daily JavaScript: empty objects
  107. Cross-platform problem solving: how an Android Pro Tip helps our web app design
  108. Stupid git tricks: transferring part of one git repo to another
  109. starting to maybe get the point of node.js
  110. Encapsulation in Javascript
  111. Consistency in Scala
  112. For-confusion in Scala
  113. Familiarity v readability

2011 25

  1. IntelliJ IDEA 11
  2. Gradle is easy: Groovy tests
  3. Git is hard: applying single commits to another branch
  4. Git is hard: amending commit history
  5. Humility in programming languages
  6. Stupid Gradle Tricks #1: what can I do in this block?
  7. Lifting the blankets of Gradle
  8. What to look for in a BPM system
  9. Dependency Injection vs Functional
  10. Setting up an Android project in IntelliJ Idea
  11. Debugging Log4J: where are my log messages going?
  12. Debugging Hibernate: what database am I connecting to?
  13. Platforms vs Process
  14. Profiling for Fun and Profit
  15. Product vs Platform in Programming Languages
  16. Dart. What’s the point?
  17. Keeping Your Cache Down to Size
  18. Goodbye, MapMaker. Hello, CacheBuilder.
  19. Stupid Oracle Tricks #1: SQL substitution variables
  20. Finding Primes in Haskell
  21. Spring configuration returns home
  22. Guava: pidgin functional programming in Java
  23. A small correction: F# active patterns
  24. Why
  25. Why now?