Hello World!

… or something like that.

My name is Reeve, and I am a Software Engineering major at FGCU in my first year. Over the years I have picked up experiences with lots of languages and frameworks, but none of it has prepared me for working with other people.

One of the most daunting things for me at the moment is the thought of trying to work with another developer on one code base. I have a little experience from a year or so ago with a friend, but that didn’t last long. The two of us won a coding competition together, worked on Minecraft plugins, and made a few games.

It was a fun time, however, I still don’t really have any etiquette when it comes to coding with others. Part of the issue with how I learned Java and the languages after it, is that I never learned the conventions officially. That is, I’m still not sure what is the norm and what isn’t (generally).

Anyhow, recently I’ve been learning Kotlin, which has been a blast. My favorite part so far is the extension functions, so you could do something like this:

fun String.test() : String {
	return this.toUpperCase()

fun main() {
	println("hello world".test())

Obviously that use is pretty pointless, but it demonstrates a usage of extension functions.

Another cool thing about Kotlin is that you’ll probably never see another Null Pointer Exception again (if you aren’t touching other languages as well). The code below shows a little of what Kotlin will do for you. In order for something to be declared as null or not initialized, you have to either add lateinit or the ? after the type. This shows that the type may be null, in which case Kotlin will give you a hard time if you try to ignore the null.

private val variable: String? = null

fun main() {
	variable?.let {

Before anyone gets annoyed that knows Kotlin, yes there are ways to ignore the null, but you’ll have to purposefully do it rather than do it unknowingly.

Anyhow the code above is basically just a normal null check with the ?.let.

In Java, the equivalent of this would be something like:

private static String variable = null;

public static void main(String[] args) {
	if (variable != null) {

Which isn’t all that much of a difference, but Kotlin will harass you if you ignore the null possibility. This isn’t always great, some people might even find it annoying, but I enjoy the little reminders it gives me and the time it saves if I had forgotten.

Another popular feature for Kotlin is the coroutines, however I have only dabbled in them a tiny amount, so I can’t really say anything on those yet, but I look forward to trying out ktor and whatnot.

This post was all over the place, but I’ll try to keep the next posts more focused. Just a small little post for the beginning but hey, gotta start somewhere.