Core Java

  • GoF Design Patterns Using Java – Part 02

    Let’s continue learning design patterns by implementing the Adapter, Facade, Template, Iterator, and State patterns using Java.

    Read more
  • Java Thread Programming (Part 2)

    Let’s see an example of where we can use Threads. Let’s assume we are building a web server that returns the most used words in a website.

    Read more
  • Java Thread Programming (Part 1)

    We write code in a file line by line, and then it gets executed. To be able to execute a piece of code requires an execution environment. In Java, a thread is an executing environment. If a program has only one executing environment, then we call this program a single-threaded program.

    Read more
  • The Debugger Checklist (Part I)

    Win at debugging by following an organized process and leveraging the tools you already have!

    We’re going to skip ahead to a point where you have a bug you can reproduce (consistently or otherwise) but you don’t understand or can’t prove the cause.

    Read more
  • SKP’s Definitive Primer: Failures, Pitfalls & Disadvantages of Microservices

    Microservice adoption has almost become the norm in most software product and IT services organizations.

    Below, I take the opportunity to make you aware of real-world issues faced by organizations of all sizes in migrating or adopting microservices.

    Since learning from others’ mistakes and knowing pitfalls upfront can be helpful in preparing and planning better, this overview will be of help to those planning a shift to a microservices strategy.

    Read more
  • Troubleshooting Java Processes Running on Your Machine

    When your application has some problem, the first thing to check is running processes on the machine.

    For Linux OS we generally use ps -ef. ps is one of the most used Linux troubleshooting commands. The JDK provides similar functionality for Java processes through jps. The jps command-line utility provides a list of all running Java processes on a machine for which the user has access rights. The access rights are determined by access-control mechanisms specific to the operating system.

    Read more
  • GoF Design Patterns Using Java – Part 01

    To understand the philosophical and historical perspective on the Gang of Four’s design patterns, I made a short, 10-minute video, which was also my PluralSight Author Audition.

    I came up with my own examples to understand design patterns further. Try downloading the code and see if it helps you in comprehending the patterns in a better way.

    Some brief code snippets follow each pattern so you can get quick demonstrations. Feel free to bookmark this article as a quick reference/cheat sheet for when you want to quickly review each of them.

    Read more
  • Deep Dive Into Multi-Threading in Java

    Multi-threading represents a very intriguing topic, even after years of research and development for high quality, robust, and efficient software. With equal emphasis on hardware improvements and the software that runs on it – we have newer paradigms for parallelism.

    The most important yet basic concepts are the ones which I present here. I then explain the intricacies of multi-threading in the Java programming language. Some of these are newer features and supported only from the Java Platform Standard Edition 5.0. Let us start with a quick overview and understanding of the core concepts.

    Read more
  • Changing a Field’s Type in Recent JDKs

    A couple of years ago, I attended a talk by my former colleague (but still friend) Volker Simonis. It gave me the idea to dig a bit into the subject of how to secure the JVM. From the material, I created a series of blog posts as well as a talk.

    From that point on, I submitted the talk at meetups and conferences, where it was well-received. Because I like to explore different areas, I stopped to submit other proposals. Still, the talk is in my portfolio, and it was requested again in 2021. I have already presented it twice since the beginning of the year at the time of this writing.

    It allowed me to update the demo with version 16 of the JDK. In this blog post, I want to share some findings regarding the security changes regarding changing a field’s type across JDK versions.

    Read more
  • Evolution of Java Memory Architecture (Post Java 7.0)

    Welcome to the next part of a series of articles on key concepts in Core Java and J2EE. The series revolves around memory architecture, connection and memory leaks, core Java syntax and semantics, Java Object layout/anatomy, multi-threading, asynchronous task execution, design patterns, Java agents, class loading, API design, OOPs & SOLID.

    Today, we learn about the evolution of the Java Memory Architecture, post Java 7.0.

    Read more
  • Evolution of Java Memory Architecture (Pre Java 8.0)

    Welcome to a series of articles on key concepts in Core Java and J2EE. The series revolves around memory architecture, connection and memory leaks, core Java syntax and semantics, Java Object layout/anatomy, multi-threading, asynchronous task execution, design patterns, Java agents, class loading, API design, OOPs & SOLID.

    In this part, we focus on the Java Memory Architecture, from before Java 8.

    Read more

Subscribe to foojay updates:

https://foojay.io/feed/
Copied to the clipboard