Posts

In my last post I discussed some of the benefits of immutable objects as well as how to implement them in Java and other languages. In this post I will introduce unmodifiable objects and discuss how to implement them and some of their uses.

Immutable objects are ones which cannot be changed once they have been created. While this is a simple idea, it is a useful tool for making your program easier to reason about. This post will discuss some of the benefits of immutable objects — or more generally, immutable data — as well as how several different languages can help to make it easier to work with such data. In particular, I will look at Java as well as Kotlin and Rust which are two relatively new languages that I have been experimenting with recently.

This blog was originally hosted on WordPress.com but I’ve decided to migrate it to GitHub Pages for various reasons. This post will outline my reasons for migrating as well as a comparison of my experiences with the two services.

In my last post I discussed my journey towards solving a puzzle using programming. It was quite a long post so I decided to leave out some details and one particular roadblock that I ran into.

About a year ago someone lent me a Tetris Cube which has been sitting in my office since then. Being a fan of puzzles I thought it would be fun to tinker away at it occasionally during any down time or if I needed to clear my mind. For a few months I would spend a few minutes here and there trying to solve it. After a while I figured that my puzzle solving skills would not be enough and decided to put my programming skills to use. Since then I have hardly touched the puzzle and I haven’t had much time to try to create a solver until recently.

It’s been a while since my last post, but it’s summer now so I’ll have time to work on some projects which I will write about in the coming weeks. Last time I mentioned using JavaFX to create the GUI for a project. In this post I will give my attempt at a JavaFX crash course as well as talk about my experiences with it so far.

In the past I’ve talked a little about some of my experiences with software testing. However, my experience with any formal approaches to testing have been fairly limited. In this post I will describe my first experience with test-driven development.

Several months ago I found myself with some free time and decided to experiment with some simple network programming. I created a simple chat program in Java using sockets. This post will describe my first experience with sockets and perhaps even serve as simple tutorial for using sockets in Java.

Throughout the past semester, as part of my computer vision course, I had to implement several image processing and computer vision techniques and algorithms to operate on grayscale images. There were three programming tasks in total. The first was to count the number of objects in a particular image, which required several simple steps. The second was to implement an edge detection algorithm, specifically Canny edge detector. The last programming assignment was to implement photometric stereo. This post will contain three (mostly) independent sections describing each of the assignments.

With recent advances in technology, new methods of computer interaction are becoming available. In this blog post I will briefly describe my investigation of gesture recognition using the Microsoft Kinect for Windows as a means of controlling software. For a much more detailed description of the methods and results of this project, you can read the paper.

In my last post about Robocode I described my attempt at a competitive one-versus-one robot. In this post I talk about my attempts to shrink my robot so that I could submit it to the RoboRumble to see how it does against other robots from around the world.

This post will likely conclude my journey with the Play Framework. Although I have not completely finished the application that I originally set out to create, I am satisfied with what I have learned about the MVC architecture, the Play Framework, and web application development in general.

This week, I’ve taken a small break from Play to work on developing an interface for the book exchange app that I’ve been working on. I have been working with Twitter Bootstrap and Divshot which I will describe in this post.

A few weeks ago I started working with the Play Framework, which claims to make it “easy to build web applications with Java & Scala.” However, I am seriously starting to doubt that. The more I use it, the less it feels like play, and the more if feels like very frustrating work.

Last week I discussed my brief experience with the Play Framework. This week I’ve continued to explore the framework with a focus on the model part of the MVC architecture.

This week I’ve started working with The Play Framework, which is a web application framework. The extent of my web development includes playing around with basic html and javascript, so this should be an intersting experience. I hope to have several updates over the coming weeks about my first real experience with web application development.

In my first post I talked about my brief investigation of a piece of open source software. Today I will attempt to explain free and open source software, as well as give my perspective on the issue.

In my last post I talked about testing the Robocode robot which I have been developing for the past few weeks. Today I will be going into more depth about the robot and the project in general.

In a previous post I touched upon the idea of testing software, in the context of FizzBuzz. Today, I will discuss testing once again. This time, instead of testing a simple program like FizzBuzz, I will be testing a more complex system. Specifically, I will be testing a Robocode robot.

Quality assurance is an important part of developing any system, product, or service; developing a software system is no exception. Quality assurance can be divided into two broad categories: automated and manual. Manual quality assurance for software systems includes, for example, unit testing and code reviews. Automated quality assurance involves the use of tools such as static code analysis tools.

Kata is a Japanese term which is usually applied to martial arts. It refers to a series of choreographed movements used to practice good technique. More recently it has been used more generally and applied to many areas outside the realm of martial arts, such as software engineering.

Do you know how to ask a question? It seems simple, right? Well, it is. Anyone can ask a question. On the other hand, asking a good question is a completely different matter. In particular, it can be very difficult to ask a good question about a technical problem.

Fizz buzz (also written as FizzBuzz) was originally a word and number game used to teach children about division. In this game children sit in a circle and take turns counting from 1. However, if a number is divisible by 3, they say “Fizz,” if it is divisible by 5, they say “Buzz,” and if it divisible by both, they say “FizzBuzz.” More recently, it has found its way into the world of programming thanks to these blogs here and here. These blogs claim that many entry-level programmers, including those with a degree in computer science, cannot write a simple program that outputs the results of FizzBuzz. My task was to time myself while writing a program in Java, using Eclipse, that would output the results of FizzBuzz for the numbers 1 to 100. Beyond this, the implementation details were left up to me. However, I was also required to implement a test of the program to verify that the output was correct.

The Three Prime Directives of Open Source Software Engineering are as follows:

1. The system successfully accomplishes a useful task.
2. An external user can successfully install and use the system.
3. An external developer can successfully understand and enhance the system.

My goal for today was to find a Java-based open source project that is of interest to me and that I could potentially contribute to. After finding such a project, I would explore how well it meets the Three prime Directive of Open Source Software Engineering.