All Content

    • Algorithms and data structures in TypeScript: string tokenizer, rate limiter

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using TypeScript. Information is depicted visually using diagrams and code snippets. This article may be useful if you are trying to get more fluency in TypeScript or need a refresher to do interview prep for software engineering roles.
    • Create a simple DSL for CSS like syntax for TUIs

      Procedural macros are a way for you to extend the Rust compiler and provide plugins that you can use to extend the language. They allow to create your own DSL (domain specific language). This article goes into the details of creating a simple DSL to mimic CSS syntax but in Rust, for a TUI app framework.
    • Guide to Rust procedural macros

      Procedural macros are a way for you to extend the Rust compiler and provide plugins that you can use to extend the language. They allow you to reduce the need to write manual boilerplate code, and even allow you to create your own DSL (domain specific language). This article goes into the details of creating the 3 kinds of procedural macros in Rust.
    • Write a Redux library in Rust

      This article illustrates how we can build a Redux library in Rust. This library is thread safe and asynchronous (using Tokio). The middleware and subscribers will be run in parallel. But the reducer functions will be run in sequence.
    • Write code using async/await in Rust

      This article illustrates how to write concurrent and parallel code in Rust using Tokio. The pedagogical example we will use is building an asynchronous implementation of a middleware runner that you might find in a Redux store.
    • Build a grep CLI app in Rust

      This article illustrates how we can build a CLI app in Rust that is a very basic implementation of grep. This app will have 2 modes of operation: piping lines in from `stdin` and searching them, and reading a file and searching thru it. The output of the program will be lines that match the search term w/ the term being highlighted. Topics like `stdin` manipulation in a terminal, detecting when the terminal is in `tty` mode vs `piped` mode, doing simple file I/O, creating non consuming builders, and managing `Result`s, along w/ building a simple CLI interface are covered in this article.
    • Build a non-binary tree that is thread safe using Rust

      This article illustrates how we can build a non-binary tree in Rust using various approaches until we end up with a version that is thread safe and supports parallel tree walking as well. Topics like interior mutability, sharing ownership, weak and strong references, custom traits for polymorphic behavior, are covered in this article.
    • Reference handbook for using Ink v3.2.0 components (w/ React, Node.js and TypeScript)

      This article is reference handbook for using Ink v3.2.0 (with TypeScript and React) components to create CLI apps. IDEA Ultimate / Webstorm project files are provided.
    • Advanced guide to Ink v3.2.0 (w/ React, Node.js and TypeScript)

      This article is an advanced guide to using Ink v3.2.0 (with TypeScript and React) to create CLI apps. IDEA Ultimate / Webstorm project files are provided.
    • Introduction to Ink v3.2.0 (w/ React, Node.js and TypeScript)

      This article is an introduction to using Ink v3.2.0 (with TypeScript and React) to create CLI apps. IDEA Ultimate / Webstorm project files are provided.
    • React hooks (v17.0.3) and Redux handbook using TypeScript (v4.3.4)

      This handbook will take you thru using function components in React and Redux (using TypeScript) and writing tests for them (using react-testing-library). IDEA Ultimate / Webstorm project files are provided. This handbook is written as a reference. You can easily jump to the section that is relevant to you or read them in any order that you like.
    • CSS responsive design using Grid, Flexbox, and media queries handbook

      This handbook is a reference guide on how to understand and use CSS to build web applications that incorporate responsive design using Grid, Flexbox, and media queries. IDEA Ultimate / Webstorm project files are provided. This handbook is written as a reference. You can easily jump to the section that is relevant to you or read them in any order that you like.
    • Node.js (v16.3.0) Handbook using TypeScript (v4.3.4)

      This handbook will use TypeScript to take you thru using Node.js. IDEA Ultimate / Webstorm project files are provided. This handbook is written as a reference. You can easily jump to the section that is relevant to you or read them in any order that you like.
    • Mechanical keyboard review - Dygma Raise

      Review of the Dygma Raise keyboard and Bazecor software from a programmer's perspective
    • Advanced guide to creating IntelliJ IDEA plugins

      Advanced guide to creating JetBrains Platform plugins: VFS, PSI, Kotlin UI DSL, Dialog, Tool window, List, Swing UI and layout managers, ConsoleView, LineMarker. This is a companion of the Introduction to creating IntelliJ IDEA plugins tutorial.
    • Mechanical keyboard review - UHK v1, Mistel BAROCCO MD770, Drop Alt Captain

      Review of the Ultimate Hacking Keyboard v1, Drop Alt Captain, and Mistel BAROCCO MD770 keyboards from a programmer's perspective
    • Linux (Ubuntu) desktop and laptop hardware review for software engineers (early 2021)

      Linux laptop and desktop for software engineers hardware review - Dell Precision 3440 2020, Dell XPS 13 Developer Edition 2021, ThinkPad P15, ThinkPad X1 Carbon Gen 8
    • Customizing Ubuntu UI

      Learn how to customize your Ubuntu UI with fontconfig, Nerd Fonts, adding gestures, customizing Terminal, and using Gnome extensions for Theming and Window tiling. And IDEA theming.
    • Publishing a Kotlin library as a Gradle dependency to JitPack or GitHub Package Repository

      Learn how to publish a Kotlin library as a gradle dependency to JitPack or GitHub Package Registry
    • fish shell scripting manual

      Short manual on how to program using fish shell's scripting language using lots of useful examples ranging from simple to complex
    • Introduction to creating IntelliJ IDEA plugins

      Introduction to creating plugins using JetBrains Plugin SDK covering these topics: PicoContainer, Services, plugin.xml, actions, extension points, extensions, testing, and the intellij-plugin-verifier. This is a companion of the Advanced guide to creating IntelliJ IDEA plugins.
    • Potential problems of using non-capturing lambdas

      This tutorial covers the potential pitfalls of using non-capturing lambdas and using use anonymous classes to implement SAM / functional interfaces instead
    • Annotation Processing in Kotlin and Android

      Introduction to Kotlin Annotation Processing on Android and how to create a static index of generated classes and interfaces (without using reflection or classgraphs)
    • Kotlin DSL Introduction

      This tutorial is an introduction to Kotlin internal DSLs using examples
    • Experimenting w/ Fibers in Project Loom preview

      This tutorial is an early exploration into Java Project Loom (preview technology)
    • A pragmatic guide to designing and building responsive web applications

      This article is a pragmatic guide for developers and designers who want to learn how to build responsive web applications
    • TypeScript starter project w/ Webpack 4, Karma, Jasmine

      This tutorial showcases a starter project for people who want to use TypeScript w/ a stater project already setup to deploy to browsers using Webpack 4, and w/ testing infrastructure configured (via Jasmine and Karma)
    • Java vs Kotlin for Android development

      This tutorial showcases the differences between using Java and Kotlin in Android development
    • Algorithms in Kotlin, Schedule ordered tasks

      This tutorial shows how one might schedule ordered tasks that need to be executed when a particular state is reached. However, these states might be reached in any order.
    • Kotlin and Test Driven Development

      This tutorial is an exploration of doing test driven development using Kotlin. This tutorial focuses on JUnit, MockK, AssertJ, and Roboelectric for Android.
    • Kotlin Sealed Classes and State

      This tutorial is an exploration of Kotlin sealed classes and how they can be used to represent state elegantly and robustly
    • Kotlin Extension Function Expressions

      This tutorial is an exploration of extension functions and higher order functions in Kotlin by example
    • Introduction to Dagger 2

      This tutorial is an introduction to Dagger 2 with a simple example of using it in Java
    • In-depth exploration of Dagger 2

      This tutorial is and in-depth exploration of Dagger 2 using Java and Android
    • Advanced Dagger 2 w/ Android and Kotlin

      This tutorial is an advanced exploration of Dagger 2 using Subcomponents and custom scopes. Android and Kotlin are used to demonstrate the use of these advanced Dagger 2 capabilities.
    • Vue.js, Webpack, Vueitify, Electron, and vue-cli

      This tutorial serves as a deeper dive into Vue, along with Vuetify (a Material Design library for Vue), Webpack, Electron, and vue-cli
    • Algorithms in Kotlin, Caches, Part 7/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Algorithms in Kotlin, Binary Trees, Part 6/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Algorithms in Kotlin, Graphs, Part 5/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Algorithms in Kotlin, Recursion, Part 4/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Algorithms in Kotlin, Stacks and Queues, Part 3/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Algorithms in Kotlin, Strings, Part 2/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Algorithms in Kotlin, Big-O-Notation, Part 1/7

      This tutorial is part of a collection of tutorials on basic data structures and algorithms that are created using Kotlin. This project is useful if you are trying to get more fluency in Kotlin or need a refresher to do interview prep for software engineering roles.
    • Getting started with Vue.js

      Vue is a competitor to React. This tutorial serves as a brief introduction to Vue, and getting started with it without using Webpack or Babel.
    • Designing for multiple screen densities on Android

      In this article, I am going to do a deep dive into Android screen density and provide some guidance on how to design for such a huge diversity of screen densities. Having a firm grasp of this is critical in being able to create wireframes and designs in Sketch that can be implemented on actual devices (phones, tablets, laptops, TVs, wearables).
    • The Princess and The Hare

      A short story about choosing to win
    • Introduction to Android Architecture Components

      The difficulties of dealing with things like configuration changes when rotating a screen, and sharing app state data between fragments and activities are a thing of the past. Architecture Components puts the magic back into Android development! 🎩✨
    • Android Downloadable Fonts

      As of Android API level 27, there are too many ways to load custom fonts in Android apps. This article will show you how to use downloadable fonts (from Google Fonts) using the latest support library. 🖋
    • Flexbox: Getting started (Part 1/2)

      The goal of this series of articles is to help you to learn Flexbox in a fun interactive way and then help you to build simple real life examples using Flexbox 📦
    • Flexbox: Building a navigation bar (Part 2/2)

      This is a second article on 2 part series. In this article you will learn how to build a simple example responsive navigation design using Flexbox and media queries. 📦
    • Getting started with MediaPlayer on Android

      This article is an introduction on how to use Android MediaPlayer in your apps to playback audio 🎵
    • Loading CSV files in Node

      Tutorial and code on GitHub that demonstrates the use of ya-csv and inquirer to load CSV files from node.js and convert them into JSON files, to generate sample data for other apps.
    • Automatically updating copyright messages in JetBrains IDEs

      Pro Tip on automatically updating copyright strings in your JetBrains based IDEs (including Android Studio)
    • Setting environment variables on macOS

      Pro Tip on setting environment variables for ANDROID_HOME and JAVA_HOME when you setup your development environment on a new machine
    • Deep dive into Android Services

      This article is a deep dive into Android Services. Learn all about started services, bound services, and bound and started services. With source code examples and a sample app.
    • Redux, React Navigation, and React Native

      This tutorial is a deep dive in the use of Redux in React Native projects. It will show you how to architect apps that rely on external web services, and Firebase. The code for this tutorial is on GitHub.
    • Painting with code - review of Airbnb's React Sketch.app plugin

      Design engineering is becoming a thing. Airbnb has created something amazing - react-sketchapp. This library can generate Sketch artifacts using Javascript and React as a starting point. This article will show you what it is, who this is for, and why it matters.
    • Flexbox layouts and lists with React Native

      This tutorial is a deep dive of Flexbox layout and FlatList. It will show you how to take a wireframe and compose React Native components out of it. The code for this tutorial is on GitHub.
    • Navigation and Styling with React Native

      This tutorial is a deep dive of React Navigation, which is the way to do in app navigation. It also goes into the best practices for styling your app and how to collaborate with designers for styling. The code for this tutorial is in GitHub.
    • Getting started with React Native

      This tutorial will show you how to get started quickly with React Native for mobile app development on Android and iOS. It focuses on Flexbox layouts, Navigation, and cross platform considerations. The code for this tutorials is in GitHub.
    • Android, Redux, Firebase Auth & Database, and Material Design

      Redux and React are things that are normally associated with web development. Redux is a beautiful design pattern that can help with any application, even native ones! I used Firebase in order to do cross platform data synchronization across web and mobile clients. I also used Firebase auth and Material Design to craft a real-world app. The code for this tutorial is in GitHub.
    • Using Firebase for user presence tracking

      This tutorial will show you how to use Firebase to to build user presence tracking into web apps. The code for this tutorial is in GitHub.
    • Building a real world app using React, Redux, Firebase, and Typescript

      The purpose of this tutorial is to serve as a starting point for a real world React, Redux, and Firebase example. The starter project is on GitHub.
    • Building a real world app using React, Firebase, and Typescript

      The purpose of this tutorial is to serve as a starting point for a real world React and Firebase example. The starter project is on GitHub.
    • On Taking Flight

      A short story about making choices
    • Ugly Beautiful

      When you know something will end, what do you do?
    • Culture in startups

      The importance of getting this right from the start
    • On Healing

      Letting go of suffering
    • Clarity

      Don’t try, just play!
    • Struggle, meet Greatness

      You are what you fight for
    • Failure

      How to keep learning
    • Loosely Coupled and Strongly Coherent

      How I code and how I live
    • Show up in the world in the right light

      What it means to "just be"
    • How I got Everything Wrong, about Everything

      How I got everything wrong about everything, then learned to see the silver linings everyday
    • Creating asynchronous servlets with Tomcat 7 (Servlet 3.0 API)

      Overall, the API is pretty straightforward to use, assuming that you are familiar with asynchronous processing in the first place. However, if you are not familiar with asynchronous processing, then this business of callbacks can be quite confusing and daunting. Additionally Tomcat 7 and Servlet API 3.0 make it easier to configure servlets using annotations. There are other cool features in 3.0 that I haven’t covered in this tutorial, like loading servlets programmatically.
    • Android Location Providers (gps, network, passive)

      The best way to handle GPS is to use the “network” or “passive” provider first, and then fallback on “gps”, and depending on the task, switch between providers. This covers all cases, and provides a lowest common denominator service (in the worst case) and great service (in the best case).
    • Android Event Dispatch Thread or Main Thread

      Android applications run in a native Linux process, in the underlying Linux OS. This process houses activities (screens), widgets, and services (non visual long running application parts). When working with Android apps, it is important to remember to keep long running code running in threads that are not tied to the main thread or event dispatch thread, in order to get an “application not responding” error. A common mistake that is made is long running tasks are performed in this EDT/main thread, and this leads to lots of application failures.
    • Using JSON for mobile object exchange

      I've been working with various object encoding schemes to get information transferred over the network between services and mobile apps running on Android and BlackBerry. On Android, I figured I would try using Java object serialization, and that works some of the time, and not for anything complex. I wish the object serialization and deserialization mechanism in GWT would be ported over to all these mobile environments, but I digress. This tutorial outlines the use of JSON for this purpose.
    • Android Animation Framework Tutorial

      This tutorial is an introduction to the built in animation frameworks that are part of the Android UI library. Without writing any animation/drawing code, you can do 2 types of animations - layout transitions that affect ViewGroups, and sequences inside a View. You can also do frame by frame animation, but this tutorial will not cover that. The basics covered here affect layout transitions, and animation of a View itself, using tweening animation, which includes each of the following effects (or any combination) - Alpha, Rotate, Scale, and Translate.
    • Android ListView and custom adapter Tutorial

      This tutorial will show you how to use ListView to display selectable lists of non trivial data, using complex cell renderers. The ListView is a selectable list. You can attach a variety of data models to it and load different display layouts (cell renderers). You can create your own model and cell renderer. This model-view combo is called an Adapter. In this tutorial, I will show you how to extend create your own Adapter from scratch, and create your own cell renderers from scratch as well.
    • Android LinearLayout Tutorial

      This tutorial shows you how to use the LinearLayout container (using Java code, not XML markup), which is the simplest layout mechanism available on Android. If you're familiar with Swing's BoxLayout then you will have a good idea of what this container has to offer. Linear layouts are really simple... you can add components horizontally or vertically to a ‘bag’ or ‘box’.
    • Android UI Themes Tutorial

      This tutorial will show you how to use Android's theme-ing capabilities. You can set background color, image, etc. on widgets, dialogs, and activities.
    • Android TableLayout Tutorial

      This tutorial will show you how to use the TableLayout container, which is like an HTML table. The UI layout code is done in Java, not XML. A class (LayoutUtils) is provided to make it easier to attach layout params to View objects.
    • Android Option and Context menu Tutorial

      This tutorial will show you how to create options menu (hooks into the MENU button) and context menu (press and hold a component).
    • Android XML View inflation Tutorial

      This tutorial will show you how to instantiate or inflate a View from XML; this is useful for components that don't provide a Java API to tweak with certain style attributes. The Button class is used as an example; you can only get certain styles to show up via XML that aren't available via the Java API.
    • Android Activity and sub-Activity Tutorial

      This tutorial will show you how to create a sub-Activity from a calling-Activity, and process the results produced by the sub-Activity, if you want to do so. Also, the various ways of launching a sub-Activity are covered, along with the Android Activity history stack. A subclass of Activity is also provided that makes it trivial to launch sub-Activities and respond to results from them.
    • Android - How to build a service-enabled Android app - Part 3/3 Multithreading

      I've written 3 tutorials to show you how to create a service enabled Android application that performs all of it's network I/O in a background thread (not the UI thread). These tutorials are split into three parts. This tutorial shows you how to use background threads to perform long running network IO operations, so that the main UI thread is not locked up.
    • Android - How to build a service-enabled Android app - Part 1/3 UI

      I've written 3 tutorials to show you how to create a service enabled Android application that performs all of it's network I/O in a background thread (not the UI thread). This tutorial shows you how to build a simple UI without using XML, by writing Java code to layout the UI.
    • Android - How to build a service-enabled Android App - Part 2/3 Networking

      I've written 3 tutorials to show you how to create a service enabled Android application that performs all of it's network I/O in a background thread (not the UI thread). These tutorials are split into three parts. This one shows you how to use Apache HTTP Client to connect to services over HTTP or HTTPS and exchange serialized Java objects with services.
    • Task API (3 of 3) - Monitoring HTTP POST operations

      Using Task API to perform HTTP POST operation in the background, while monitoring the request and response I/O operation data streams
    • Geocoding tutorial - Accessing Google Static Maps from Java

      Given an IP address, this tutorial will show you how to get a Google Static Map from it
    • Task API (2 of 3) - Task API in-depth

      More details on the Task API introduced in the first Task API tutorial. SampleApp from the first tutorial is dissected under a microscope along with the API itself. Also contains information on which external libraries are optional and which are required.
    • Task API (1 of 3) - Quick Start Guide

      Introducing the Task API. Easy to use background task API for Swing. Android and JavaME implementation coming soon. Easily create tasks and monitor their progress and cancel them at any time. Easily manage multiple tasks. Create network aware tasks and recurring tasks, and much much more! The API is open source (Apache 2.0 license). Enjoy!!!
    • SwingX Tutorial - Busy Label (JXBusyLabel)

      This tutorial will show you how to use SwingX's JXBusyLabel component to display an indeterminate progress indicator. It will also show you advanced configuration options that allow you to create different and interesting indeterminate progress indicators using the BusyPainter.
    • SwingX Tutorial - Task Pane (JXTaskPane, Container)

      This tutorial will walk you through the steps required to use JXTaskPane and JXTaskPaneContainer in SwingX. You will learn how to change the default color schemes of these components, and add components and actions to task panes.
    • SwingX Tutorial - Painters

      This tutorial will introduce you to the SwingX API and the concept of Painters. It will give you an idea of the kinds of effects you can create with them as well, with code examples.
    • What is XML? An introduction

      What is XML? This tutorial provides a brief review of the W3C XML 1.0 Recommendation itself.
    • SwingWorker details - canceling background tasks in flight

      This tutorial outlines some of the interesting behaviors exhibited by SwingWorker when running background tasks are canceled in flight
    • How to use the AnimatedTransition API (SwingX and Timingframework)

      I needed to perform animations in the app that I'm building for ScreamingToaster desktop app framework using Java and Swing. I needed to build animations that show a transition from one screen to another. This is slightly different than creating custom, or modified components which perform a function and have a set of graphical effects. I needed animations that would transition my user interface from one "screen" to the next. The screens themselves could be panels or components (part of the whole app, or the entire app itself). While I'd been writing much of this code myself, to do these animations, it just got really tedious and frustrating to add this level of complexity to my code, when all I needed were some simple animations. I've been using the SwingX API and the TimingFramework API to perform the animations and leverage the components, however, this last piece was missing. And this last piece just got delivered by Chet Haase, as a part of the binary deliverables with his (and Romain Guy's) great book - Filthy Rich Clients.
    • How to use glass pane for animation (SwingX and Timingframework)

      I needed to perform animations in the desktop app framework that I'm building for ScreamingToaster. I needed to build animations that move various components around on the screen, and other animations that pop up components on top of existing components, etc. After creating a few of these effects, I realized that I was doing the same thing over and over again, which is why I decided to write this tutorial to encapsulate this pattern, in the hopes that I will help others doing the same thing.
    • Creating multi-threaded Swing apps that consume web services

      If you've ever want to incorporate web services into your graphical applications / applets / widgets written in Java, then there are some threading issues that you have to be mindful of, and design around. This tutorial will guide you though some of the important threading issues you have to keep in mind when building such applications. The strategies outlined in this tutorial apply to accessing more than just web services from Swing apps; it also applies to loading information from databases, and performing any other kind of time consuming process that has to happen in the desktop app and interact with it, but can't make the user interface unresponsive.
    • Introduction to Java 5 java.util.concurrent API

      Introduction to the Java5 Concurrency API. Java 50 introduces the java.util.concurrency API, which leverages hardware level constructs to allow Java programs to use lock-free, and wait-free thread-safety mechanisms, without having to use native code.
    • Advanced Threads

      This tutorial is devoted to showing you advanced techniques of using threads to perform event driven tasks, without using polling, and usually with the use of queues. Along with techniques of managing life cycles of server objects (that are multithreaded) and runtime activation and deactivation of these objects.
    • Introduction to Threads

      Introduction to multithreading in Java
    • XML and Java Tutorial, Part 1

      In this tutorial, we will create an XML document, the contents of which can be accessed using a JFC/Swing application and from a web browser (via a Servlet). The XML document is a very simplistic representation of an address book which stores the name, email and company name of people. The XML document is written manually, and its structure is known by the Swing application and the Servlet.

    Subscribe to RSS feed