rl_design_dev.md

Design and Development

• Encapsulation: I Don’t Think it Means What You Think it Means
• Exercises in Kotlin: Part 4 – Control Flows and Return
• Test Estimation Techniques (If You Must…)
• API microservices, the Unix philosophy, and the Richardson Maturity Model
• Microsoft integrates Xamarin into Visual Studio for free, will open source Xamarin runtime
• JUnit 5 – Extension Model
• First Preview of Android N: Developer APIs & Tools
• Smashing the Stack for Fun & Profit : Revived
• Serverless Architectures
• Java 8 – Functional Interfaces (SAM)
• Quickstart Boot and ClojureScript
• Implementing an annotation interface
• Verifying DateTime and Date with Hamcrest
• Monads (and Functional Programming) in Ruby with Monadt
• Exploring Rust
• Data aggregation with Spring Data MongoDB and Spring Boot
• Apache Kudu as a More Flexible And Reliable Kafka-style Queue
• A Template System for Google Docs: Google Drive Automation With Google Execution API
• How Agile Changes Testing, Part 3
• Scala Notes Futures – 1
• Code Review and Single Responsibility Principle
• How to not break the internet with this one weird trick, bundle your code
• Animating with React, Redux, and d3
• Java compile in Java
• Scalaz Features for Everyday Usage Part 3: State Monad, Writer Monad, and Lenses
• Dealing with releases of single page applications
• JavaOne 2015: Advanced Modular Development
• Publish Subscribe model in Kafka
• Akka basics
• Five Agile Testing Approaches That You Should Know About
• Developing Spring Boot Applications With Kotlin
• So you want to build a generator…
• Whirlpool: Microservices Using Netty And Kafka
• My Increasing Frustration With Clojure
• The Blockchain Explained to Web Developers, Part 2: In Practice
• Unit vs Integration Akka Testing
• Open Sourcing Pytest Tools
• JPA Pitfalls / Mistakes
• Testers Don’t Prevent Problems
• Writing iOS games with Swift and Sprite Kit, part 2: Responding to touches
• Java 8: Declare Private and Protected Methods in Interfaces
• Mobile Onboarding: Interact, Don’t Tell
• Bumpversion is automation for semantic versioning
• Getting Out of JavaScript Fatigue – React Edition
• Real World Microservices: When Services Stop Playing Well and Start Getting Real
• Implementing a Stepping Debugger in JavaScript
• A Basic Builder With Groovy
• Spying on the DOM
• Static Methods are Fine
• 7 lessons I learned while creating my new SAAS: YourSetup.io
• Embed Everything!
• Java 8 CompletableFutures Part I
• Testing Improvements in Spring Boot 1.4
• OpenJDK – Is Now the Time?
• Non-lexical lifetimes: adding the outlives relation
• Always Start With Eager Initialization
• Escaping Technical Debt With Agile Methodology
• Swift and Go
• Understanding git for real by exploring the .git directory
• Safely invoking removeAtIndex
• Investigating Erlang by reading its system calls
• Vaadin Treetable Example
• JUnit 5 – Conditions
• Six nifty ES6 tricks
• Amazon takes on PayPal and others with launch of Amazon Payments partner program
• The Basics of Akka
• SpringBoot : Working with JOOQ
• Improve User Experience With Real-Time Features
• How to get started with Android development
• Introducing venv-update
• ES6 Module Loading is More Complicated Than You Think
• Beautiful Constructors
• Non-lexical lifetimes: introduction
• Beyond Memory Safety With Types
• 5 Things Your QA Manager Wish You Knew About Software Testing
• Java EE 8, What is the Current Status: Case Study for Completed Work Since Late 2015
• Patterns in Scala: 101
• What is HATEOAS?
• Basic JavaScript arrays reminder
• The Best of Both Worlds
• Simple Everyday Tips for Vaadin Developers (Part 5: Data Grid)
• Two Weird Tricks with Redux
• Testing web services with traffic control on Kubernetes
• Higher-rank and higher-kinded types
• Test Faster and Smarter by Testing in Production
• Ionic vs. Pure Cordova: Three Reasons Ionic Wins
• Deploying REST APIs to Docker Using Ruby and Sinatra
• Dubious Decisions: Passing on TDD
• API Blueprint Evolving in Two Areas Where OpenAPI Spec (aka Swagger) Falls Short
• Non-lexical lifetimes based on liveness
• Kotlin for Java Developers: 10 Features You Will Love About Kotlin
• So If You’re Using Tag Libraries for Your View Models You Have To Test Them, Right?
• JUnit 5 – Architecture
• A polyglot’s guide to multiple dispatch – part 4
• Developing our first iOS App with React Native (pt 2) – User Auth
• A Taste of JavaScript’s New Parallel Primitives
• Protect Your Immutable Object Invariants in More Complex Java Objects
• Kotlin Month Post 3: Safety
• Software maintenance is an anti-pattern
• Why TDD Should Not be Controversial
• The Path to Rust
• Distributed Quasar Actors with Kafka and ZeroMQ
• High-Impact, Minimal-Effort Cross-Browser Testing
• Dropping Webhooks
• Android apps with Python, Flask and a WebView
• Efficient Integer Overflow Checking in LLVM
• Abstractions and the role of a framework
• Perl toolchain for building micro-services at scale
• Something Isn’t Something Else
• Splitting a Monolithic Application Into Services
• 5 API Testing “Must Haves” for API Security, Reliability, Performance
• Parsing any language in Java in 5 minutes using ANTLR: for example Python
• Vaadin Data Binding Example
• The Elixir of concurrency
• Building helpful CLI tools with Go and Kingpin
• How To Engineer A Good Build Process
• Your JAX-RS APIs Were Not Born Equal: Using Dynamic Features
• Well-Written Java 8, 8 Ways
• Python Serialization Performance
• Bluebird in the wild: Advanced promise-based workflows
• Java EE vs Java SE: Has Oracle Given up on Enterprise Software?
• Giving Up on TDD
• A Distributed, Asynchronous RESTful Framework Prototype
• The Truth Behind the Big Exceptions Lie
• Unhelpful abstractions
• Don’t use the greater than sign in programming
• The Netflix Stack, Using Spring Boot Part 2: Hystrix
• Encouraging you to develop the three great virtues of a programmer: laziness, impatience, and hubris
• Getting Ready For HTTP/2: A Guide For Web Designers And Developers
• a lambda is not (necessarily) a closure
• Opportunistic salvage driven by tests
• Not All Beginnings Must Have An End
• Why API Providers Should Offer SDKs
• Elixir RAM and the Template of Doom
• Multidimensional algorithms and iteration
• Going native with React Native
• Observations From A History of Java Backwards Incompatibility
• The Simple Leads to the Spectacular
• Understand How Much Memory Your Python Objects Use
• The Importance of Algorithms as Microservices
• Why You Should Consider React Native For Your Mobile App
• Going global with React
• Rapid API Prototyping with Bottle.py
• NPM & left-pad: Have We Forgotten How To Program?
• Jetty Session Clustering Example
• How I fixed libuv
• Generic binary trees in ES6
• Software Automation On a Budget
• Software Can’t Live On Its Own
• Jank Busters Part Two: Orinoco
• Working With Akka Actors
• The spectacular instability of good code structure
• Spring Boot With JSPs Using Undertow
• Prototypal Object-Oriented Programming using JavaScript
• The Primary Reason for Moving to Microservices Should Be Non-Technical
• Getting Started with Angular 2
• Codifying the Rules Used to Organize Your Code
• Functional architecture is Ports and Adapters
• Ceylon on mobile devices
• Continuous Installation Checking
• Mutation Testing
• CSS coding techniques
• Git Pull vs Git Fetch (and Stashing)
• Walking the Microservices Path Towards Loose Coupling? Look out for These Pitfalls
• Notes on Reactive Programming Part I: The Reactive Landscape
• Singleton (Patterns, 20 Years Later)
• Spring Batch as a Framework for System Integration
• CSS Variables in WebKit
• Setting Up Distributed Infinispan Cache with Hibernate and Spring
• Learning Rust: Sharing My Queue Between Threads
• Good Abstractions Have Fewer Leaks
• Some thoughts on clojure.spec
• Code Coverage Isn’t Only for Unit Tests
• Testers Need Serious Help – Are We Listening to Them?
• The Promises and Challenges of std::async Task-based Parallelism in C++11
• Microservices Approach to Processing System Logs into Real Time Actionable Events
• RankBrain Survival Guide
• How to Avoid Brittle Code
• New Language Features on the JVM
• Bidirectional Data Flow – A Double Edged Sword?
• What’s in a Clojure Namespace?
• Authentication in Golang With JWTs
• SQLite: The art of keep it simple.
• A useful new strace feature
• Thrift API Gateway – Part 2: Spring Domination
• O Java EE 7 Application Servers, Where Art Thou?
• Write opinionated workarounds
• Stop Anticipating Change
• To promise or to callback? That is the question…
• Please, Java, Support Multiline String Literals
• Rust via its Core Values
• Map, Reduce and other Higher Order Functions
• Man vs. Tool?
• Java: Immortal Objects and Object Resurrection
• Programmatic jcmd Access
• Methods Name Change a Lot
• How I Learned to Love TDD
• Poor man’s generics in Golang (Go) [or pick your poison]
• Simple Event Driven design
• Quality Matters: The Benefits of QA-Focused Retros
• Identifying and quantifying architectural debt
• Debugging Node.js in Chrome DevTools
• How to Develop iOS Apps on Linux using React Native
• How to Make a Piechart using React and d3
• Kotlin + Android First Impressions
• RESTful Day #3: Resolve Dependency of Dependencies With Managed Extensibility Framework (MEF)
• The Strict Aliasing Situation is Pretty Bad
• Creating Proxy Objects Using djcproxy
• Stateful or Stateless Classes
• Delivering Octicons with SVG
• Vaadin Rest Example
• The Composite Builder Pattern, an Example of Declarative Programming
• Segfaults are our friends and teachers
• My Journey to Face the Lambda Expressions in Java
• I Was Wrong About TypeScript, Here is Why
• Object Oriented Inheritance in Go
• Microservices – Myths and Misunderstanding
• AWS SQS and Spring JMS integration
• Testing your app on a budget
• Generator comprehensions
• The Role of Log Files in Experiments
• PoLA and HttpURLConnection
• Hystrix Part 1: Getting Started With Hystrix
• How to @Inject Property File Properties With CDI
• Managing two million web servers
• Spring-managed Transactions Explained – Part 2 (JPA)
• Leapfrog Probing
• Polling is a Hack: Server Sent Events (EventSource) with gevent, Flask, nginx, and FreeBSD
• The Error Model
• 6 Reasons Test Management is Critical in an Agile World
• Longevity of Source Code
• A reactive serverless cms for the technology blog
• Catching Exceptions
• A succesful Git branching model considered harmful
• Microservices Arrived at Your Home
• Builder in C#
• Java 8: Use Smart Streams with Your Database in 2 Minutes
• A polyglot’s guide to multiple dispatch – part 3
• Java 8: Default Method Resolution Rules
• The Little Architect
• New Concurrent Hash Maps for C++
• Pair Programming – The Most Extreme XP Practice?
• Embedded Wednesdays: Tools of the Trade
• Ceylon: Object construction and validation
• Implementing Queues for Event-Driven Programs
• A Small, Nice Thing
• Retry handling with Spring-Retry
• React and the economics of dynamic web interfaces
• Java Remote Debug for Applications Running in Kubernetes
• What’s up in Swift Language Evolution
• JSON-LD: Building Meaningful Data APIs
• Creating an AndroidWear watchface using Kotlin
• Testing Swift Code – Approaches & Useful Libraries
• Teaching: Convergence and Divergence
• Learn Lua from JavaScript, part 3: Object-oriented behavior
• Ubuntu on Windows — The Ubuntu Userspace for Windows Developers
• A Quick Primer on Microservices
• Shims, Jigs and Other Woodworking Concepts to Conquer Technical Debt
• How to spy on a Ruby program
• Software Design Patterns Are Not Goals, They Are Tools
• Cohesion – The Cornerstone of Software Design
• Custom Infix Functions in Elixir
• The Sad State of the Backbone Ecosystem
• How Do You Know When to Touch Legacy Code?
• It’s All A/Bout Testing: The Netflix Experimentation Platform
• Quick Start Tutorial: Universal React, with Server Side Rendering
• Demystify Java Class Loading
• Sub-processing with modern C++
• How to reduce the cognitive load of your code
• How Dependency Injection (DI) Works In Spring Java Application Development
• Android Activity Transition Example
• An introduction to LLVM in Go
• XRay: a function call tracing system
• Building more accessible technology
• Why SpringBoot?
• AngularJS Project Structure
• Securing a JSON API REST Service With Spring Boot and Elide
• Building better mobile apps for work
• Killing CORS Preflight Requests on a React SPA
• The Frustration and Loneliness of Server-Side Javascript Development
• Simple, safe multimethods in Racket
• Why we chose Akka for our Cloud Device solution
• Almost complete guide to flexbox (without flexbox)
• Getting Started With Hazelcast and node.js
• Why we use web components and Polymer
• Processing JSON With Jackson
• Dear Erica: What’s the biggest and best Swift 3 change?
• A Python Ate My GUI
• Logging Into a Spring Boot/Elide JSON API Server
• Does Curry Help?
• Microservices vs. SOA
• Why I Chose Scala Over Java
• Python is better than C! (Or is it the other way round?)
• Getting Started with TDD in React
• Native HTML Apps with Xamarin
• Akka Tutorials: Messages Between Actors v.2
• CI, Breaking Builds, Bisecting, And Reverting
• The Joys and Woes of Pair Programming
• Moving On
• Code Review and Single Responsibility Principle
• Testing Angular 2 Applications
• Async systems with sync clients
• Pushy Automata
• Powerful Tactic to Use Exception Mapper in Dropwizard
• String Builders and Smart Compilers
• Abstraction Considered Harmful
• Closure-based State in F#
• Why I love ugly, messy interfaces – and you probably do too
• Swift for the Java Guy: Part 2 – The basics
• Exercises in Kotlin: Part 1 – Getting Started
• A better way to structure D3 code
• Static and Ahead of Time (AOT) compiled Julia
• When to Rewrite from Scratch – Autopsy of a Failed Software
• Retrying Method Execution using Spring AOP
• Revert on Red Build
• Java 8: Declare Private and Protected Methods in Interfaces
• Access-Control-Allow-Origin Header and the ASP.NET Web API
• The Top 100 Clojure Libraries in 2016
• Golang – The annoying remote import path
• 12 Great Web Service Testing Tools
• Implied Readability
• The Deep Roots of Javascript Fatigue
• Creating a language (Enkel) on the JVM
• Multithreading in modern C++
• Strategic Scala Style: Practical Type Safety
• Server-Side Rendering With React, Node And Express
• Hacking Sunday – Javascript metaprogramming – Overwriting localStorage
• Kotlin Month Post 1: Assorted Features
• Testing Multithreaded Code in Java
• Addressing the Api Consumption Side: 5 Predictions for 2016 & Beyond
• Why Async?
• Anatomy of a bug fix
• Java Builders From The Start
• Scala notes – Futures – 2 (Promises)
• Responsive Tables: CSS Only, No JavaScript
• Monads: It’s OK to Feel Stupid
• Testing Java EE (or Why Integration Tests Are Overrated)
• Why agile isn’t agile without continuous delivery
• LeftPad and Go: can tooling help?
• How a Leading Financial Services Company Scaled Test Environment Access and Saved $2M+
• Microsoft kills Project Astoria, its tool for porting Android apps to Windows 10
• Back to the CompletableFuture: Java 8 Feature Highlight
• A QA Manager’s Guide to Reducing Project Cost With API Virtualization
• How to build mobile apps on Google Cloud Platform
• The Importance of Using Concurrent Collections in Multi-threaded Applications
• Isolating integration tests and mocking dependencies with Spring Boot
• Singleton Pattern: The Good, the Bad, and the Ugly
• Is Functional Programming really slow?
• Vaadin Layouts Tutorial
• Please, kill your darlings
• Writing Next Generation Reusable JavaScript Modules in ECMAScript 6
• New APIs to help developers improve scroll performance
• Constraints
• Four months with Haskell
• A Better Varargs
• Insights From Stackoverflow: Most Voted for Spring 4 Questions
• The MVVM Pattern – Design Time Data
• Complex Test Objects Made Easy in Java
• Java 8 HashMaps, Keys, and the Comparable Interface
• RESTful Web Services With Python Flask
• Understanding nested list comprehension syntax in Python
• Returning multiple values from functions in C++
• Being Picky with JMS
• MathML is a failed web standard
• Five Tips for Writing Flexible Code
• Fundamental refactoring vs elaborative refactoring
• go channels are bad and you should feel bad
• JSON Compression by Rotating Data 90 degrees
• How SpringBoot AutoConfiguration magic works?
• Extension/Service/Plugin Mechanisms in Java
• The Physical Web expands to Chrome for Android
• OCaml Love
• Mockito Tutorial for Beginners
• Testing Clojure macros with metadata
• Easy Database Manipulation with Groovy and Gradle
• Using Traits in Java 8
• Infinite collections with ES6 generators
• Shadow Fields vs. Property Accessors Interface Round 3
• Is There a Simple Coverage Metric?
• Clojure: First steps with reducers
• Testing Isn’t Only for the Technical Team: The Tests Your Business Needs to Be Doing
• Spring Boot and Database initialization
• Logging v. instrumentation
• Simplify Web Service Development With HTTP-RPC
• Java Will Get Local Variable Type Inference
• You Are Not Checking
• Continuous Stress Testing for your JAX-RS applications with Gatling + Gradle + Jenkins Pipeline
• The promise of static typing
• Arrays: Disarray or Datarray?
• Simple Asynchronous Microservices using Lambda Architecture.
• Why do record/replay tests of web applications break?
• Rebound & Integration: Making Sure No Data Gets Lost When Synced
• Flexbox: Responsive Comment Section with HTML5 and CSS3
• Declarative Design Tools
• Evolution of Systems Integration
• Android From Scratch: Building Your First Android Application
• Learn Lua from JavaScript, part 2: Control flow and data structures
• Building GORM Criteria Queries Dynamically
• Swift: The joy of sequences
• Continuous Code Reviews & Quality Releases
• Introducing Hazelcast Scala API With Aggregations
• Why Microservices Should Be Event Driven: Autonomy vs Authority
• Introduction to Microservices Part 1
• If Java Is the Matrix, Then Scala Is the Red Pill
• Long Compile Time in Swift? Could be the Literal Parsing Bug
• The Magic Vs Boilerplate Trade-off
• Python vs. Java: Duck Typing, Parsing on Whitespace and Other Cool Differences
• I’ve Just Liberated My Modules
• Unit Testing Allowed Me to Pick Up My Kid Today
• The Top 100 Java Libraries in 2016 – After Analyzing 47,251 Dependencies
• A Declarative Architecture for Swift Apps
• Surprises in Ruby HTTP libraries
• Stupid Swift Tricks #4: Writing A Big App In It
• Groovy Retrospective: An Addendum – Memory Usage and PermGen
• Taming the Golang Stack Trace
• Printing arrays by hacking the JVM.
• Code Faster with Fewer Bugs
• Four SPI Flavors: Stateful Using History API
• Ember.js: Introducing Subteams
• Disadvantages of purely functional programming
• Practical Golang: Getting Started With NATS and Related Patterns
• Playing with key generators, redux
• Playing with C++ Variadic Templates and Dynamic Programming
• Richardson Maturity Model and Pizzas
• An Analysis of the JavaScript Package Ecosystem npm
• An Ingenious Workaround to Emulate Sum Types in Java
• Functional Programming Is Not Popular Because It Is Weird
• A Resizable Concurrent Map
• Java Websocket Containers: The Possibilities
• Exercises in Kotlin: Part 5 – Classes
• Design Rule Spaces: A new form of architectural insight
• Modernized Pattern Implementation With CDI: The Maximal Decoupled “Virtual Chain Of Responsibility”
• Expecting Failures in Microservices and Working Around Them
• How to Create a News Reader With React Native: Web Page Component
• A Modern App Developer and An Old-Timer System Developer Walk Into a Bar
• Dynamic code generation in C#
• On the Madness of Optimizing Compilers
• Battling Cyclomatic Complexity in Java using Javaslang
• Carving the Java EE Monolith Into Microservices: Perfer Verticals Not Layers
• Ceylon on Android
• Try and Catch in Golang
• Spring Async and Java’s 8 CompletableFuture
• Read YAML in Java with Jackson
• Immutable pointers – a pattern for modular design to help achieve microservices
• JUnit 5 – Basics
• State of affairs: Bootstrap 4 vs Foundation 6.2
• Type Checking Modular Multiple Dispatch with Parametric Polymorphism and Multiple Inheritance
• One Thing Good Spring Developers Know
• Spring Security with Spring REST Web-service
• Why CSP matters I: Keeping things in sync
• Dynamic, static, optional, structural typing and engineering challenges
• Type Specialization in Scala
• Code Smells – Part II
• More readable Javascript without variables
• Developing for Direct Boot
• A WebAssembly Milestone: Experimental Support in Multiple Browsers
• How We Use Neo4j to Manage Microservices at Veneto Banca
• Is there any evidence for ripple effect?
• Incremental computation and the web
• Introducing React Storybook
• Integrating Quartz with Spring
• Using React Native: One Year Later
• Why Is No One Writing Language Runtimes?
• Distinguished Microservices: It’s in the Behavior
• Groovy Goodness: Using Tuples
• Mimicking npm script in Node.js
• So You Want to Use Pathnames…
• On the “naturalness” of buggy code
• A Smallish List of Parse Migration Guides
• Reclaiming Design Patterns (20 Years Later)
• A multi-order radix tree
• Building Pinterest’s A/B testing platform
• The future of loading CSS
• How Agile Changes Testing, Part 4
• Build End-to-End Cloud Apps using Swift with Kitura
• Npm package author revokes his packages, breaking tons of builds
• Grids in a SPA: Integrating JQGrid With Spring MVC and GSON
• R Learning Path: From beginner to expert in R in 7 steps
• Micro-services for performance
• Mobile vs. Web: Which Is Harder to Test?
• Design Patterns in the Real World: Flyweight
• Using Templates to Transform Web Service Results into Markup
• UI Developers! Choose Sensible Default Ordering!
• Let’s Write Redux!
• The Rust Community
• Streaming template literals
• Streaming over Maps with Java 8
• Building Accurate Visual Diffs
• The Expression Problem and its solutions
• API Versioning Methods, a Brief Reference
• Cache-Control: immutable
• So You Want to Be a (Compiler) Wizard
• A Story of Checked Exceptions and Java 8 Lambda Expressions
• Currying Functions in Scala
• Customizing Spring Roo tagx
• An overview of realtime libraries and frameworks
• Microservices are about applying a group of Best Practices
• Go – Making a program 70% faster, by avoiding common mistakes
• Finding a needle in a haystack
• Flexbox & the keyboard navigation disconnect
• Triassic Park: The Swift Evolution
• Lambda crabs (part 1): A mathematical introduction to lifetimes and regions
• Spring Boot and AngularJS Integration Tutorial
• How To Build CRUD REST APIs With Elixir And Phoenix Quick Start
• The pastiche test
• Comparing Rust and Java
• Spark Streaming Testing with Scala Example
• Probabilistic Programming in Scala
• Configure multiple View Resolvers in Spring
• Event Driven Architecture
• Step by Step Guide To Building React Redux Apps
• Why we moved to React
• Scalable Microservices through Messaging
• Java EE 8 MVC: Global exception handling
• A new mobile friendly testing tool
• Build a new Web Application from scratch using Spring boot, Thymeleaf, AngularJS – Part 3
• Coordination in Akka
• The Elements of Style
• Retro on the Julia Programming Language
• Scala EE: Bring the Hate
• Erlang Scheduler Details and Why It Matters
• Git hooks for continuous integration
• Cohesion – The cornerstone of Software Design
• Pimp My Code, Book 2: Swift and Dynamism
• Firefox Can Now Get Push Notifications From Your Favorite Sites
• First Steps Into the World of Go
• Hard Facts About the ROI of Software Testing
• Finally, Real-Time Django Is Here: Get Started with Django Channels
• Ember & Data Down, Actions Up
• Constructor or Setter?
• Ratpacked: Using Spring as Component Registry
• How to Implement a Smart Chunking Bootstrap Carousel with AngularJS
• Comparing Golang with Java
• Kotlin-like Builders in Java and Python, Continued: Additional Parameters
• On the need of a generic library around ANTLR: using reflection to build a metamodel
• How to Pattern-Match Files and Display Adjacent Lines in Java
• The hunt for an immutable, type safe data record in JavaScript
• Messy Structs/Classes in a Functional Style
• A More Distilled Version of an API ‘Getting Started’ Page on a Developer Portal Homepage
• How to Support Java 6, 8, and 9 in a Single API
• Writing an OS in Rust: Kernel Heap
• Learn Lua from JavaScript, part 1: An introduction to Lua
• The Beauty Of React Native: Building Your First iOS App With JavaScript (Part 1)
• The 80% rule
• Aspect Oriented Programming with Spring Boot
• How to enable bytecode enhancement dirty checking in Hibernate
• Async and Await
• Determining the Active HotSpot Garbage Collector
• Closure-based State: Java
• Spring Batch Exception Handling Example
• Kotlin Month Post 4: Properties
• Regressive Web Apps
• How to build static checking systems using orders of magnitude less code
• How to create a custom Slack integration using webhooks
• What’s in a Continuation
• The Parameterless Generic Method Antipattern
• Java 8 – Default Methods in Interfaces
• Gauging the Performance of Your QA Teams
• Giving up on Julia
• Plug in Your Own Components With Java 8
• The Beauty Of React Native: Building Your First iOS App With JavaScript (Part 2)
• Functional programming in Python: a little bit more
• Groovy Goodness: Creating Files and Directories With a Nice DSL Using FileTreeBuilder
• A Geospatial Messenger With Kotlin, Spring Boot and PostgreSQL
• OCaml mimicry in Java
• Improved Documentation of HotSpot Options in Java 8
• Progressive Enhancement and Modern JavaScript
• Aligning text smartly in CSS
• Git Mind Map
• JavaScript through Ruby Eyes
• How to Pick Dependencies From a Developer’s Point of View
• Costs And Benefits Of Comments
• The benefits of static typing without static typing in Python
• Playing with key generators
• Scala: Higher-Order and Anonymous Functions
• Collaborators and Libraries: Java Design Patterns for Success
• Beware Of findFirst() And findAny()
• Spring Web Flow Tutorial
• Design Patterns: Observer Pattern
• Your First Lagom Service – Getting Started With Java Microservices
• Practical Reverse Engineering Part 1 – Hunting for Debug Ports
• 100% Coverage is Possible
• Using Java 8? Please Avoid Functional Vomit
• Creating a Document-Store Hybrid in Postgres 9.5
• How to Run User Tests Successfully: The ‘Why’ Question
• How to build your Property Management System integration using Microservices
• Unsafe abstractions
• The release of Pants 1.0
• Play in Action – Building REST Services
• Oracles from the Inside Out, Part 9: Conference as Oracle and as Destination
• Constant errors
• The Most Important Code Metrics You’ve Never Heard Of
• First Steps to Using Spring Boot and Cassandra
• Writing Tests Doesn’t Have to Be Extra Work
• Put Your Java 8 Method References to Work
• Exploring fork (2) and sockets in Nim
• Friday Q&A 2016-03-04: Swift Asserts
• NPMGate == Supply Chain Fail
• Metrics considered charmful
• Using React Instead of Dijit with Dojo Toolkit (Part 1)
• Vaadin Widgetset Example
• Polymorphism in Python
• Static Methods are Fine
• Unpacking Tuples in C++14
• (Ab)using Java 8 FunctionalInterfaces as Local Methods
• Debug JavaScript With These 14 Tips
• Data Models and Word Size
• How Agile Changes Testing, Part 2
• Clang vs. GCC – code coverage checking
• Restful Java Metering by Dropwizard Metrics
• What should I learn next as a programmer?
• Distributed Game of Life in Elixir
• Increase your dependencies
• Double-ended vector – is it useful?
• Shadow Fields vs. Property Accessor Interface
• Working With Resources, Folders, and Files
• Best Friends: C++11 Move Semantics and Pimpl
• 10 Tips on How to Build the Perfect SDK
• you can take the derivative of a regular expression?!
• Composition vs. Inheritance
• Should you be scared of Unix signals?
• Avoid Working With Classes and Reflection Where Possible
• A polyglot’s guide to multiple dispatch – part 2
• Kerberos User Impersonation on Tomcat With Apache HttpComponents
• Ceylon Might Just be the Only (JVM) Language that Got Nulls Right
• Refactoring a javascript video store
• Your Microservices Effort Will Fail If You Only Focus On The Technical Details
• Delay With JMS: From Configuration to Flow Testing
• Simple coroutines for games in C++
• That Code’s Not Dead – It Went To a Farm Upstate… And You’re Paying For It
• Gson: Deserialization of Generic Types
• Event-Driven Data Management for Microservices Part 5
• Creating real-life motion effects in d3 visuals
• Object Construction and Validation
• Kill Your Dependencies
• Thinking in Abstractions
• Mixin Class Composition in Scala
• How to Build Rails APIs Following the json:api Spec
• Performing 20,000 concurrent file searches in less than 1 minute.
• Akka Notes – Finite State Machines – 2
• Java Design Pattern Simplified – Part 1 of DJANGO Untamed Series
• Efficient JAX-RS: Conditional Gets & Puts
• Learning New Technologies By Doing
• Using d3js transitions in React
• Algebraic Data Types & Monads in Ruby with the Monadt Gem
• False Sharing, Cache Coherence, and the @Contended Annotation on the Java 8 VM
• Rage Against The Finite-State Machines
• Rust + nix = easier unix systems programming <3
• Coordination in Akka
• 30 years later, QBasic is still the best
• Google Resizer Cares for Responsive Design
• How to Do NULL Right
• An example of releasing the GIL with Cython: Multi-threading spaCy’s parser and named entity recogniser
• OpenComponents – microservices in the front-end world
• Centralized logs with rsyslog, systemd and golang
• Inheritance Is Terrible
• Scalaz features for everyday usage part 1: Typeclasses and Scala extensions
• A Few Thoughts About Kotlin and Why I Like It So Much
• A Tool For Thought
• The Netflix Stack, Using Spring Boot – Part 3: Feign
• The Blockchain Explained to Web Developers, Part 1: The Theory
• Finite state machines with Akka
• How Software Gets Bloated: From Telephony to Bitcoin
• WHY WON’T THIS WORK?! Coding Angry for Fun and Profit
• Setting Up Distributed Infinispan Cache with Hibernate and Spring
• Transforming Collections – Java 8 Collectors API
• Cargo: predictable dependency management
• Best practices for concurrency control in REST APIs
• Houdini: Maybe The Most Exciting Development In CSS You’ve Never Heard Of
• The bad practice in FOSS projects management
• Protocol-Oriented TableView and CollectionView
• CSS For Backend Developers – Part I
• A cache miss is not a cache miss
• So you want to write a package manager
• My First Steps In Rust
• Java 8: A Type Safe Map Builder Using Alternating Interface Exposure
• Why I’m Choosing C++
• Laziness at extreme: developing JAX-RS services with Spring Boot
• Javascript Fatigue? Or something more?
• Who Should Be Afraid of Agile Testing?
• Testing AWS Scala Microservices
• Developer Experience (DX) – Devs Are People Too
• Why Rust’s ownership/borrowing is hard
• Akka Tutorials: Messages Between Actors – Part 1
• Build a new Web Application from scratch using Spring boot, Thymeleaf, AngularJS – Part 1
• API Names and Begging the Negatives
• Building Microservices: Using an API Gateway Part 2
• When You Need an Explanation?
• Metadata: Holistic Configuration Management at Facebook
• The Joy and Agony of Haskell in Production
• DRY’ing Elixir Tests with Macros
• The Difference Between Functional and Non-Functional Testing
• Selecting the best artwork for videos through A/B testing
• 5 Items to Consider When Refactoring an API
• Create a JSON API REST Service With Spring Boot and Elide
• Query Classes
• “I know how to program, but I don’t know what to program”
• Testing and Dependency Injection With Model View Presenter on Android
• Combining the power of Gradle, Flyway and JOOQ for seamless development with databases
• Google may be considering Swift for use on Android
• Builder in Java
• 3 Steps For Analyzing a Gradle Project With SonarQube Using Docker
• Why Microservices?
• Hotspot Patterns: The formal definition and automatic detection of architecture smells
• The Open Session In View Anti-Pattern
• 3 KPIs Used to Measure the True ROI of Agile Testing
• Reflections on Programming
• Design Patterns Are Not Blueprints
• Multithreading in C++11/14 – Part 9
• Type Wars
• How I fell in love with a programming language
• Open Source: Great Power Comes With Great Responsibility
• Rust for Web
• Cleanly Handling a Fork on GitHub
• A Quick Introduction to RxJava: From Reactive Programming to RxJava in Action
• Visualizing Your (Real) Architecture
• Code through the looking glass: All you need is a dictionary (and O(N) )
• A toy generational garbage collector
• Avoiding Javascript’s “Undefined is Not a Function” w/Constants
• Functional Core Reactive Shell
• Promises: All The Wrong Ways
• The Netflix Stack, Using Spring Boot – Part 1: Eureka
• Why I don’t use CSS preprocessors
• Abstract Factory or Factory Method?
• 3 Easy Things to Do to Make Your Microservices More Resilient
• Skill Development in Exploratory Testing
• How Etsy Formats Currency
• Strings in Java 9
• To DRY or Not to DRY: A Matter of Boundaries
• Type-Safe Flux Architecture Using TypeScript
• CompressedOops: Introduction to compressed references in Java
• How to combine the Hibernate assigned generator with a sequence or an identity column
• How Go solves so many problems for web developers
• A Doomed Code Review
• Object Behavior Must Not Be Configurable
• Mockito Captor Example
• Abandoning Gitflow and GitHub in favour of Gerrit
• Introducing Tera, a template engine in Rust
• The State of the Module System
• Bots won’t replace apps. Better apps will replace apps.
• The real responsive design challenge? RSS.
• From Java Anonymous Class to Single Line Lambda in 3 Steps
• Stack traces and the errors package
• Akka Notes – Finite State Machines – 1
• Performance These Days
• Windows Subsystem for Linux Overview
• Microservice Architectures With Spring Cloud and Docker
• Is Reactive Programming the Holy Grail?
• Why you should use Clojure for your next microservice
• Implementing A Bounded Context
• Elmification of Swift
• Extreme Laziness: Developing Jax-RS Services With Spring Boot
• What’s in a Build Tool?
• clojurescript defprotocol’s secret
• A second try at using Rust
• d’Oh My Zsh
• Parsing UDP in Elixir with Binary Pattern Matching
• Readability matters
• How to call SQL Server stored procedures and functions from Hibernate
• Inter-Process Communication in a Microservices Architecture
• Constructor Function: Scala
• Java 8 Deferred Invocation with Java Util Logging
• How to Convert SVG Sprite into PNG Images
• Interfaces – The Most Important Software Engineering Concept
• The Node.js Event Loop is a Damn Mess
• Microsoft gives developers new options to plug into Office 365
• Swift Guide to Map Filter Reduce
• Dependency Injection in Bottle/Flask (Python)
• Scalaz features for everyday usage part 2: Monad Transformers and the Reader Monad
• A Two Month Debugging Story
• Is it worth persevering with Golang?
• Code Generation and Templating Made Really Easy
• Reflections on ESLint’s success
• Using API Simulation to Build Microservices Alongside a Java Monolith
• Simple Everyday Tips for Vaadin Developers – Part 2: Using CDI
• Learning Rust: Iterator
• Good Configuration Feedback is Essential
• What Most People Are Searching on Google? Let’s Explore Google Hot Trends…
• Design Patterns: Decorator Pattern
• Parsing Java 8 Streams Into SQL
• Mobile UX Design: The Right Ways to Ask Users for Permissions
• Spring Annotation Processing: How It Works
• Swift for the Java guy: Part 1 – Getting Started
• Getting started with scala-native
• Frameworks don’t make much sense
• How to do distributed locking
• Dialogue’s Guiding Principles, or a Healthy Hatred of OOP
• Mocking File Inputs in JavaScript and Ember.js
• Rails has won: The Elephant in the Room
• Feature Bias, or Rethinking the Blub Paradox
• Advanced config with configuration meta-data in Spring Boot
• Designing Your Own Spring Boot Starter – Part 1
• A Context-Driven Approach to Automation in Testing
• Scala HTTP Example
• Ratpack, Couchbase, and RxJava
• Application Modules and Entity Cache
• Should You Follow the Rules?
• Why rewrite a shell script in Python?
• Grouping, transforming and reduction with Java 8
• Java and Memory Limits in Containers: LXC, Docker and OpenVZ
• Let it crash
• Creating an Observable in RxJava
• Spring Boot Configuration Tutorial
• React Native Experimental Navigation with Redux
• Spring Security 4 for Spring MVC Using Spring Data JPA and Spring Boot
• 9 things every React.js beginner should know
• Apple’s declining software quality
• Intro To Basic SIP Architecture
• Creating a Microservice? Answer these 10 Questions First
• Issues with asynchronous IO in web applications
• Error Context – a stack trace for data
• NPM module Browser-Sync in Java / Web projects
• Dirty Hacks Are OK
• Four Lessons Learned From Making Customer Value Your Priority
• Effective Spring Transaction Management
• How the heck does async/await work in Python 3.5?
• Top-8 Mistakes in A/B Testing To Avoid
• Code reviews are not about coding standards
• Start Simply, Simply Start
• & vs. ref in Rust patterns
• Watch Out For Recursion in Java 8’s [Primitive]Stream.iterate()
• 10 Features I Wish Java Would Steal From the Kotlin Language
• Event-Driven Architecture 101: Continuous Query Cache
• Lombok, a compile time Java annotation preprocessor to minimize code size
• Extensible Libraries With ServiceLoader and Spring
• Component Based Architecture
• A Gentle Introduction to Functional JavaScript – Part 1
• Sendfile – a system call for web developers to know about!
• The State of Browser APIs – 1
• Swift: Caveats for Structs as data models
• The Sega Saturn and Transparency
• Simple workflow for building web service APIs
• We have always been at war with UI
• Strong vs Weak References
• As Expected
• The SOLID Principles in Real Life
• 5 Ways to NOT Mess Up Your Microservices in Production
• Functors, Applicatives, and Monads in Plain English
• Bootstrap 4: A Visual Guide to What’s New
• Folding the Universe Part I: Functional Java
• Is Polyglot Programming Practical?
• How we accidentally doubled our JDBC traffic with Hibernate
• Faster Testing, the Exploratory Way
• JavaScript’s type system
• Using Protocol Constraints Instead Of Extending
• String Types in Rust
• The Essence of Scala
• Components involved in creating a robust Micro Service Architecture
• The Top 10 Exception Types in Production Java Applications – Based on 1B Events
• Power, minimal detectable effect, and bucket size estimation in A/B tests
• Clean architecture of Selenium tests
• Cleaner Responsibilities – Get rid of equals, compareTo and toString
• The surprising cleverness of modern compilers
• Dropwizard Part 3: Measuring Your Application Metrics
• Don’t be an Evolutionary Programmer
• Python Collections Abstract Base Classes
• Getting Started With Play Framework
• Decision Driven Test Management – 6 Tips to Improve the Value of Your Testing
• CSS Exclusions and Grid Layout
• Scala notes – Futures – 3 (Combinators and Async)
• Is Open Source Eating the World?
• Scientist: Measure Twice, Cut Over Once
• Do Experienced Programmers Use Google Frequently?
• Why Microservices Should Be Event Driven: Autonomy vs. Authority
• The Logic Behind Transactions: Distributed, Two-Phase, and Compensatory
• Production postmortem: A null reference in our abstraction
• Creating Immutable Classes in Java
• A Second Generation Reactive Foundation for the JVM
• The Maximal Decoupled “Parameterized Factory-Method-Pattern”
• A polyglot’s guide to multiple dispatch
• Statistics for Software
• Building Reactive Systems with JavaFX
• High Stakes Programming by Coincidence
• Metrics for Microservices
• Add Custom Functionality to a Spring Data Repository
• Spring Oauth2 with JWT Sample
• The Zen of Missing Out on The Next Great Programming Tool
• Doubling Down on Protocol-Oriented Programming
• Writing Integration Tests for RabbitMQ-Based Components
• jdk 8: arrays#sort vs. arrays#parallelsort
• On the Virtues of Avoiding Parsing or Basing Logic on toString() Result
• Outside In Or Inside Out
• A Practical Guide to building a Blog with React, Express and MongoDB – Part 1: Intro, Setup and WebPack
• Lug-Nut Driven Development (LuDDite)
• Custom Deleters for C++ Smart Pointers
• Using the HTTP Package
• Why Rust for Low-level Linux programming?
• 100+ Awesome Web Development Tools and Resources
• Property-Based Testing for Serialized Data Structures
• Introducing DGit
• ES6 & ES7 in the browser
• Swift Abstract Syntax Tree
• Applying Java 8 Idioms to Existing Code
• Solving the Josephus problem in Kotlin
• Beyond Beginning Git: Exclude and Interactive Add
• OO Design Is More About ‘Doing’ Than ‘Being’
• Make Your Factories Beautiful
• The Fucking Open Web