- Rethinking MonadError
- Creating a Recursive Descent Parser
- Exploring Scala Macros
- Asynchronous Programming and Scala
- Types and Functions
- Scala, Cake Patterns and the Problem
- Composing Service Layers in Scala
- An ode to the Kind-Projector and Partial-Unification
- Secure Password Hashing
- Accessing Kubernetes Pods from outside the Cluster
- The v28 Android Design Support Library
- Battle of the Tokenizers
- Towards Scala 3
- Macros: the Plan for Scala 3
- The Entity Service Antipattern
- Services by Lifecycle
- Evolving away from Entities
- The Magpie Developer
- No More Transformers: High-Performance Effects in Scalaz 8
- Subtype type classes don't work
- Optimizing Tagless Final – Saying farewell to Free
- Google Duplex: An AI System for Accomplishing Real World Tasks Over the Phone
- Writing an Internal DSL in Scala
- Phantom Types in Scala
- On Bifunctor IO and Java's Checked Exceptions
- Bifunctor IO: A Step Away from Dynamically-Typed Error Handling
- Checked exceptions I love you, but you have to go
- Separating Control and Data Planes in Kong
- Announcing the Kubernetes Ingress Controller for Kong
- Kong CE 0.13.0 released
- Understanding When to use RabbitMQ or Apache Kafka
- Product with Serializable
- Scala Enumerations Hell
- Tagless Final Algebras and Streaming
- 10 Reasons to Learn Scala and FP
- Typelevel ecosystem: a high-level overview
- JavaScript Promises: an Introduction
- ES7 async functions
- Why coroutines won’t work on the web
- On properly using volatile and synchronized
- Enforcing a Locking Context on Variables in Scala
- Arrays and Replication: A MongoDB Performance Pitfall
- Implicit Implications (part 1): Implicit Parameters
- Implicit Design Patterns in Scala
- Kotlin Android development - 6 months into it
- Zero-Overhead Tree Processing with the Visitor Pattern
- uJson: fast, flexible and intuitive JSON for Scala
- So, what's wrong with SBT?
- FastParse 1.0: Past, Present & Future
- How Linux Programs are Executed
- How Linux Programs are Executed: ELF Binaries
- Tearing apart printf()
- JWT, JWS and JWE for Not So Dummies! (Part I)
- Concurrency Concepts in Java
- Microservices, Service Mesh, and CI/CD Pipelines: Making It All Work Together
- Distributed Systems In One Lesson
- The Event Loop
- The Paved PaaS To NodeJS Microservices
- Brad Whittington - Getting Superbalist.com through Black Friday
- Spire by Example
- Intervals: Unifying Uncertainty, Ranges, and Loops
- Leveraging Spire for complex time allocation logic
- Monad transformers down to earth
- Uniting Church and State: FP and OO Together
- Existential Types — Make OOP Great Again!
- Don't trust Time
- Understanding Bitwise Operators
- Bitwise Operators in C and C++
- How to conduct a good Programming Interview
- Scala Vector operations aren't "Effectively Constant" time
- Warts of the Scala Programming Language
- Easy Parsing with Parser Combinators
- Type Classes and Generic Derivation
- Crushing boilerplate with Scala Macros
- Bits of Shapeless part 1: HLists
- Bits of Shapeless part 2: Generic Derivation
- The Aux Pattern
- Scala 2.13 Collections Rework
- Scala 2.13 Collections Feature Freeze
- Understanding F[_] in Scala
- JVM Internals
- Java Code To Byte Code - Part One
- Functors and things using Scala
- Ring Buffer: The Data Structure Behind Disruptor
- Keys, Credentials and Storage on Android
- Use the Decorator Pattern for clean I/O boundaries
- Referential Transparency
- Scala 2.13’s Collections
- Why JWTs Suck as Session Tokens
- JSON Web Tokens vs. Session Cookies: In Practice
- Refresh Tokens: When to Use Them and How They Interact with JWTs
- Parsing JSON is a Minefield
- HEVC, VP9 and The Future of Video Codecs
- How to navigate the deceptively simple Singleton pattern
- Exploring Android P: Priority Buckets
- Publishing your Android, Kotlin or Java library to mavenCentral
- How to migrate from Android-Job to WorkManager
- Android Studio 3.2 Beta
- What Happens If Your JWT Is Stolen?
- How we implemented consistent hashing efficiently
- Apprentice Blog of the Week: Did Java Break My byte?
- Unsigned Integer Arithmetic API now in JDK 8
- The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)
- The char Type in Java is Broken
- Rank Hotness With Newton’s Law of Cooling
- How to turn ugly Java APIs into elegant, type-safe Scala APIs
- Extending RequestContext in akka-http for fun and profit
- Arrows, Monads and Kleisli — Part I
- Arrows, Monads and Kleisli — Part II
- 5 steps of creating your very first Type Class in Scala
- What I Learned Making My Own JIT Language
- 5 Tips for Reducing Your Java Garbage Collection Overhead
- 5 Coding Hacks to Reduce GC Overhead
- The Trove Library: Using Primitive Collections for Performance
- React Native: A retrospective from the mobile-engineering team at Udacity
- Loop vs System.arraycopy
- Urban Performance legends - Revisited
- Bits of Shapeless part 1: HLists
- Bits of Shapeless part 2: Generic Derivation
- Teaching Evolution With Genetic Algorithms
- Implicits, type classes, and extension methods, part 1: with type classes in min
- Implicits, type classes, and extension methods, part 2: implicit derivation
- Rolling Your Own Monad To Deal With Nested Monads In Scala
- Akka, Monix, ZIO - Part 1
- Akka, Monix, ZIO - Part 2 - Communication
- Akka, Monix, ZIO - Part 3 - Supervision & Error Handling
- How not to be a mediocre developer!
- Case Study - Solve Crosswords Puzzle
- Clarifications on the Incapsula Redis security report
- Redis Lua scripting: several security vulnerabilities fixed
- Implicits, type classes, and extension methods, part 1: with type classes in mind
- Implicits, type classes, and extension methods, part 2: implicit derivation
- Implicits, type classes, and extension methods, part 3: conversions and implicit-based patterns
- Implicits, type classes, and extension methods, part 4: understanding implicits
- Akka anti-patterns: Java serialization
- Speeding up the HTTP service with Redis caching
- Why Scala?
- Windows Command-Line: Backgrounder
- Windows Command-Line: The Evolution of the Windows Command-Line
- Basics of Futexes
- Lucene: The Good Parts
- Akka HTTP Request/Response Scope Operations, vs. Deferred Operations
- The UX behind designing better forms
- Why Scala?
- Higher-kinded types: the difference between giving up, and moving forward
- Keep your domain clean in Event Sourcing
- Simple Scala Stack
- Machine Learning is Fun! Part 1 - What is machine learning?
- Machine Learning is Fun! Part 2 - Making Smarter Guesses
- Machine Learning is Fun! Part 3 - Deep Learning and Convolutional Neural Networks
- Machine Learning is Fun! Part 4 - Modern Face Recognition with Deep Learning
- Machine Learning is Fun! Part 5 - Language Translation with Deep Learning and the Magic of Sequences
- Machine Learning is Fun! Part 6 - How to do Speech Recognition with Deep Learning
- Machine Learning is Fun! Part 7 - Abusing Generative Adversarial Networks to Make 8-bit Pixel Art
- Machine Learning is Fun! Part 8 - How to Intentionally Trick Neural Networks
- Typedapi
- Shared State in Functional Programming
- Who implements the typeclass instance?
- Equivalence versus Equality
- Generalized Algebraic Data Types in Scala
- How to Automate Surveillance Easily with Deep Learning
- Saga, Compensate for failures in a terse and composable way
- This is How Google will Collapse
- A developer’s guide to web design for non-designers
- Why Developers Become Frustrated And Companies Can’t Find Talent
- The Angry Programmer
- How To Prevent Coding “Heroes” From Destroying The Team
- The Doctor And The Scalpel
- Goodbye, Object Oriented Programming
- Why Blockchain is Hard
- We fired our top talent. Best decision we ever made.
- 10 Common Software Architectural Patterns in a nutshell
- Service Mesh – A New Pattern, Not A New Technology?
- Improving Akka dispatchers
- Reactive streams for RabbitMQ with Monix
- Why you should know Monix
- How to review the code and not destroy the universe
- Avoiding Unnecessary Object Instantiation with Specialized Generics
- Pros and cons of functional programming
- These four “clean code” tips will dramatically improve your engineering team’s productivity
- Why DRY can be misleading
- Essential Cheat Sheets for Machine Learning and Deep Learning Engineers
- Convolutional Neural Networks from the ground up
- Tail calls, @tailrec and trampolines
- Tail Call Elimination in Scala Monads
- Heterogeneous Lists and the Limits of the Java Type System
- Strings Are Evil
- Deep Dive into Math Behind Deep Networks
- Reactive Streams in Scala: Akka Streams vs Monix - Part 1
- Reactive Streams in Scala: Akka Streams vs Monix - Part 2
- Reactive Streams in Scala: Akka Streams vs Monix - Part 3
- Announcing Okio 2: Our fast + simple I/O library, Okio, has a new release that supports Kotlin
- A major release just around the corner — meet Kotlin 1.3-M2
- HTTP conditional requests
- Understand Containers 1: OCI Specification
- Understand Containers 2: Linux Namespaces
- Understand Containers 3: Linux cgroups
- Understand Containers 4: Linux Capabilities
- Understand Containers 5: Mount and Jail
- Understand Containers 6: User and Root
- Understand Containers 7: Hooks and Network
- Understand Containers 8: Use CNI to setup network
- How to translate your API with Shapeless
- Are Scala Futures the past?
- Typeclass Proposal
- Http4s error handling with Cats Meow MTL
- Markov Chains
- Gang of Four Patterns in a Functional Light: Part 1
- Gang of Four Patterns in a Functional Light: Part 2
- Gang of Four Patterns in a Functional Light: Part 3
- Gang of Four Patterns in a Functional Light: Part 4
- To tag a Type
- Parallelize tests in SBT on CircleCI
- Strings are not the Type you are looking for
- Effect Extensions Pattern
- Chain – Replacing the List Monoid
- Kinds of Types in Scala, Part 1: Types, what are they?
- Kinds of Types in Scala, Part 2: Take Type, return Type or Type parameters
- Kinds of Types in Scala, Part 3: Embedding some more info in a Type
- What the Heck is OAuth?
- How We Found a Missing Scala Class
- Traversing Object Graph with Shapeless (and Why You Should Write the Same Code Twice)
- New pretty id generator in scala-id-generator
- Code formatting: scalafmt and the git pre-commit hook
- Monad Error for the rest of us
- Towards 3B time-series data points per day: Why DNSFilter replaced InfluxDB with TimescaleDB
- TimescaleDB vs. InfluxDB: purpose built differently for time-series data
- How Spam Filtering Works: From SPF to DKIM to Blacklists
- GeoMapping and the Travelling Salesman Problem
- Java's new Z Garbage Collector (ZGC) is very exciting
- Scala Wars: FP-OOP vs FP
- Data Modeling in FP vs OOP
- Cryptography—What Is It and How Does It Work?
- Git Workflows
- Electron is a hulking monstrosity of a WORA framework, and it needs to be replaced.
- What should replace Electron as a WORA framework?
- 90 New Features and APIs in JDK 11 (Part 1)
- 90 New Features and APIs in JDK 11 (Part 2)
- JDK 12 News: Switch Expressions and Raw String Literals
- Falsehoods Programmers Believe About Phone Numbers
- A Guide To OAuth 2.0 Grants
- OAuth 2 Simplified
- Identity, Claims, & Tokens – An OpenID Connect Primer, Part 1 of 3
- OIDC in Action – An OpenID Connect Primer, Part 2 of 3
- What's in a Token? – An OpenID Connect Primer, Part 3 of 3
- What is the OAuth 2.0 Password Grant Type?
- Using Facebook Login with Existing Login Systems
- Greedy, Brittle, Opaque and Shallow: The Downsides to Deep Learning
- Contravariant Functors — An Intuition
- How Netflix works: the (hugely simplified) complex stuff that happens every time you hit Play
- Approaches to JSON internationalisation (i18n)
- Monads for functional programming in scala
- Disambiguating 'this' in Scala, or what does 'self =>' mean?
- Anatomy of functional programming
- Anatomy of an algebra
- Anatomy of a type class
- Raytracing
- The Illustrated TLS Connection
- Lessons learned from creating a rich-text editor with real-time collaboration
- Digging into Docker layers
- Why the net giants are worried about the Web 3.0
- Blockchain is not only crappy technology but a bad vision for the future
- The Empire Strikes Back with a Coordinated War on Crypto
- The CIA just lost control of its hacking arsenal. Here’s what you need to know.
- Docker COPY: Dockerfile best practices
- Do VPNs Actually Protect Your Privacy?
- Thread Pools
- Explore Witnesses as an Alternative to Implicits
- Immutable State in Real World
- A streaming library with a superpower: FS2 and functional programming
- 5 themes for Scala programming in 2018
- Kubernetes Chaos Engineering: Lessons Learned — Part 1
- Functors and Applicatives
- Why x86 won’t survive
- GraphQL: A Retrospective
- At 22 years old, Postgres might just be the most advanced database yet
- Concurrency Glossary
- HTTP/3 Explained
- Scrap Your Type Class Boilerplate (1/2)
- Scrap Your Type Class Boilerplate (2/2)
- The Contravariant Functor!
- Good code is Short, Simple, and Robust
- How To Handle Errors On JVM Faster
- Understanding Contramap
- TimescaleDB 1.1 performance optimizations and PG11 Support
- The F-words: Functor and Friends
- Anatomy of a Scala quirk
- Consider Yourself a Developer? You Should Solve the Project Euler Problems
- Using jlink to Build Java Runtimes for non-Modular Applications
- You don’t understand your Software Engineers
- Why Open Source Failed
- Java Money and the Currency API
- Builder Pattern in Scala with Phantom Types
- Scala Best Practices
- ECDSA: The digital signature algorithm of a better internet
- Why are we getting Streams in Redis?
- The TypeScript Tax
- ‘The Art of Computer Programming’ by Donald Knuth
- Bye bye Mongo, Hello Postgres
- The End Is Near for Mobile Apps - Part 1
- The End is Near for Mobile Apps - Part 2
- Type Erasure in Scala
- Purely functional Parallelism in Scala
- Get 3x the capacity for your Kubernetes Cluster for free, too good to be true?
- Scheduling in Kubernetes, Part 1: Node Affinity
- Scheduling in Kubernetes, Part 2: Pod Affinity
- Apache Kafka and MQTT: End-to-End IoT Integration
- What Is Project Valhalla?
- Project Valhalla: A First Look at L-World Value Types
- The Tao of Ticketing
- User Managed Access - UMA 2.0
- Divide & Encode: How to Encode Videos Blazingly Fast
- Building a scalable, highly reliable, asynchronous user service
- Big Data Storage Wars: Ceph vs Gluster
- The Agile Crisis — a Primer
- Neotypes (Part 1): Akka-http + neo4j
- Journey Planning… And Why I Love Cypher
- Identify domain-model boundaries for each microservice
- The 10 Operating System Concepts Software Developers Need to Remember
- Phone numbers must die
- ZIO & Cats Effect: A Match Made in Heaven
- What is high cardinality, and how do time-series databases like InfluxDB and TimescaleDB compare?
- Bet you can’t solve this Google interview question.
- Using 47 Degree's Fetch library with ZIO
- Solving the Rubik's Cube with Group Theory and Functional Programming
- Permutations as Functions
- The Group Typeclass
- For Better Computing, Liberate CPUs From Garbage Collection
- Faster script loading with BinaryAST?