A fun Java concurrency problem has been seen around some corners of the internet. I'm not sure of the real origin of this problem, but I was introduced to it from a friend of a friend who saw a poster somewhere around an Amazon stand at some software engineering conference. It centers around a simple Java class ThreadNinja which uses reckless synchronization around methods and is designed to generate a deadlock. The goal is to describe a scenario in which a deadlock would occur. The puzzle part if not too puzzling, but not obvious at first glance, so I thought I'd throw in my two cents and maybe show some code that could be used to prove (and I use the term lightly) the outcome. 

I faced a non-unique problem, my API kept getting duplicate requests in rapid succession from time to time. One of those "It works on my machine" issues that I only saw in a production environment and only due to some misbehaving clients. I know APIs are supposed to be stateless and idempotent and all those buzzwords... I had all that and more, however the duplicates kept coming in, causing the need for cleanup scripts and subtle bugs downstream in a large enterprise system.

I'm going to show approaches of implementing what I call "advanced enums" in C#, since they aren't natively supported. With these techniques we will see, many advantages of more sophisticated enumerations, their use and implementations. Take this with a grain of salt if you are a language purist you probably won't like what you see. I'm going to try and change you mind.

There are different terms that describe the job of someone who creates software, and some such terms carry a type of stigma along with them. Here's my attempt to rant about what I think the difference is between two very popular terms: Software Engineer and Programmer.

There is a problem that very often tends to pop up in a lot of technical coding interviews because the solution can be trivial if the candidate understands core concepts of computer science such as recursion and depth first search. It also reveals in-depth knowledge of graphs and common graph traversal algorithms. The problem statement is, given an NxN matrix which contains only 0's and 1's find the number of islands within the matrix. An island is defined as adjacent matrix cells containing 1's, where adjacent means horizontal, vertical and diagonal neighbor cells. In this article I present an efficient enough algorithm with O(n) complexity that takes advantage of a depth first search approach to quickly iterate through the matrix and recursively detect islands.

If you have ever looked into Scala at any point you would’ve heard the term Algebraic Data Types

The goal here is to attempt to explain what that is since it’s kind of an obscure concept from an OO view point. Even though you could draw a parallel between algebraic types and Composition vs Inheritance, it’s not quite the same thing. So it’s worth while to try to understand ADT for what it is.

With all the hype and buzz around micro services and containers and APIs and  (insert buzz word here) many in the industry are talking about the CAP theorem. It seems like every software engineer is expected to know what it is all of a sudden. OK, that maybe an over exaggeration, clearly if you're not building distributed applications you won't have a clue as to what I'm ranting about here... But lets face who isn't writing distributed applications these days? 

So, the age-old question, Java vs. ‘fill in the blank’. If you are a java developer (sorry Engineer), then you love Java, and you spend time arguing with co-workers about why Java is better or at least not worse than their language of choice. These arguments never end, and will never end, that’s because there are so many languages out there and every month some new language is created which is claimed to be the solution to all our problems.