- 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
-
-
Save sahinakyol/43a18de74489892ef5ee0ceada4b619d to your computer and use it in GitHub Desktop.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment