-
Build with Naz : Rust lifetimes
Rust lifetimes are key part of the type system which allows the Rust compiler to make its memory safety guarantees. We will explore subtyping, variance, references, memory aliasing, splitting borrows, and clone on write in this article, its video, and repo. -
Build with Naz : Explore Linux TTY, process, signals w/ Rust
This article, along with related videos and the repository, explores Linux TTY, shells, processes, sessions, jobs, PTYs, signals, and more using Rust. It explains /dev/tty and describes how terminal libraries like crossterm and termion build on top of stdio and /dev/tty. The article provides examples of using Rust to send and receive POSIX signals, communicate with processes via IPC, and spawn processes. Additionally, it includes examples of using PTY in Linux and controlling external commands (such as binaries like bash) using asynchronous Rust. -
Build with Naz : Box and Pin exploration in Rust
This tutorial, video, and repo are a deep dive into Rust `Pin` and `Box` types, along with concepts of ownership and borrowing. We will also cover a lot of background information on the concepts of operating system process, memory allocation and access, stack, and heap. The examples we create are designed to demonstrate the different semantics around the use of boxes and pinned boxes in Rust. -
Build with Naz : Rust async in practice tokio::select!, actor pattern & cancel safety
This tutorial, video, and repo are a deep dive into the concept of cancellation safety in async code using Tokio and Rust. It affects the `tokio::select!` macro, and what happens to the racing `Future`s that don't win. The examples provided here, along with the video, will go over both code that is is cancellation safe and code that is not. These examples reflect real-world patterns, and are a generalized form of them. -
Build with Naz : Ubuntu 24.04 setup and config for dev productivity
I've provided scripts for setting up a new Ubuntu 24.04 desktop machine. They have been tested on a fresh install of Ubuntu 24.04 LTS. They contain all the software that is needed for Rust development, OBS Studio use, and general developer productivity. They are highly opinionated for my use case, but you can modify them to suit your needs. -
Build with Naz : Markdown parser in Rust and nom from r3bl_tui
This tutorial and video are a deep dive in a real Markdown parser written using nom in Rust. This MD Parser is part of the r3bl_tui crate, which is part of the r3bl-open-core repo. It goes over the architecture of thinking about building complex parsers and the nitty gritty details the runtime nature and behavior when combining nom parsers. -
Build with Naz : Rust error handling with miette
miette is an excellent crate that can make error handling in Rust powerful, flexible, and easy to use. It provides a way to create custom error types, add context to errors, and display errors in a user-friendly way. In this article, video, and repo, we'll explore how to use miette to improve error handling in your Rust applications. -
Build with Naz : Rust typestate pattern
The Typestate Pattern in Rust is a way to manage objects that go through different states in their lifecycle. It leverages Rust's powerful type system to enforce these states and transitions between them, making your code safer and more predictable. Learn all about it in this article, its video, and repo. -
Build with Naz : Linux io_uring and tokio-uring exploration with Rust
Explore the Linux io_uring syscall with the tokio-uring crate in Rust. This article, video, and repo will show you how to use the tokio-uring do async file IO at the OS level, and how to use it to build a simple echo TCP server, for use with netcat. -
Build with Naz : Rust async, non-blocking, concurrent, parallel, event loops, graceful shutdown
In this article, video, and repo learn effective async Rust using real world patterns that show up consistently when creating non blocking, async, event loops, using channels. Delve into implementing the Future trait and async executor manually. Also explore graceful shutdown, when not to use async, and how to think about testing async code. -
Build with Naz : tokio tracing & OTel and how to use it in Rust
In this article, video, and repo learn how to use tokio tracing and OpenTelemetry (with Jaeger) in async Rust to instrument your code and collect telemetry data for observability. -
Build with Naz : Rust Polymorphism, dyn, impl, using existing traits, trait objects for testing and extensibility
Learn how to implement effective Rust polymorphism, using `dyn`, `impl`, existing traits, and trait objects for testing and extensibility, in real world projects. -
Build with Naz : Build interactive and non blocking CLI apps with ease in Rust using r3bl_terminal_async
The r3bl_terminal_async library lets your CLI program be asynchronous and interactive without blocking the main thread. Your spawned tasks can use it to concurrently write to the display output, pause and resume it. You can also display of colorful animated spinners ⌛🌈 for long running tasks. With it, you can create beautiful, powerful, and interactive REPLs (read execute print loops) with ease. -
Write a simple netcat client and server in Rust
A guide on how to a simple Rust netcat client and server -
Write a simple TCP chat server in Rust
A guide on how to create write a simple TCP chat server in Rust using Tokio -
How to overcome your fear of git merge conflicts
A visual guide on how to understand git merge conflict messages and resolve them with confidence. -
tuify your clap CLI apps and make them more interactive
A guide on how to add minimal interactivity to your clap CLI apps using tuify. It doesn't have to be an all or nothing approach w/ going full TUI or CLI. -
Use just to manage project specific commands
A guide on how to create just files (which are like make files) to manage project specific commands. In a cross platform way. -
Build a Chrome Extension using Manifest V3
A guide on how to build a Chrome Extension using Manifest V3 that replaces the use of bookmarks (in a way) allowing you to create your own names for a URL or a set of URLs. -
Build with Naz : Comprehensive guide to nom parsing
This tutorial and video are a comprehensive guide to parsing with nom. We cover the basics of parsing and how to use nom to parse a string into a data structure. And more complex topics like human readable error reporting, and building up complex parsers. We will create a variety of different examples ranging from parsing simple CSS like syntax to a full blown Markdown parser. -
Algorithms and data structures in TypeScript: non binary tree traversal
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. -
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.
👀 Watch Rust 🦀 live coding videos on our YouTube Channel.
📦 Install our useful Rust command line apps usingcargo install r3bl-cmdr(they are from the r3bl-open-core project):
- 🐱
giti: run interactive git commands with confidence in your terminal- 🦜
edi: edit Markdown with style in your terminalgiti in action
edi in action
