Hello for the first time reader! I thought that I should start my adventure into blogging the same way you start your adventure into any new programming language; “Hello, World!”

I’m going to go through my programming journey up to this point by writing hello world in several of the languages that I’ve worked with over the years. First, Scratch:

Scratch Hello, World

My first experience actually programming was during a summer class. I can’t remember how young I was, or what game I ended up making, but I remember enjoying it. However, I didn’t do much programming until highschool. For all four years, I was involved in a program called Project Lead The Way. It was geared towards kids who thought they were interested in engineering and it allowed us to dip our toes in a lot of different areas.

In my second year, we did some very basic programming to interface with different sensors and motors. I have no clue what language we were using at the time. In my third year, I started to dig in even more, and I think that was when I decided that I wanted to study Computer Engineering in college. We didn’t do a lot of programming in that class, but we did learn a lot about basic computer science (ex: boolean logic) and computer hardware (ex: flip-flops).

To get a head start for college, I decided that I wanted to learn a programming language. After doing some research to see which one I should learn first, I went with one of the most highly-recommended beginner languages; Python!

print("Hello, World!")

I started learning by reading Learn Python the Hard Way. I was a security guard for a beach during the summers and I spend most of my on-the-clock free time either reading or writing code.

View from my beach

Good times.

After that, I started college at the University of Illinois Urbana-Champaign. During my freshman year, I got my first experience programming in assembly. In our intro class, ECE 120, we learned LC-3:

        .ORIG   x3000
        LEA     R0, LINE
        PUTS
        HALT
LINE    .STRINGZ "Hello, World!"
        .END

The language was developed in part by a professor at UIUC. It was used to introduce us to the basics of how a computer computes, and later on in our curriculum, we ended up implementing a fully functional LC-3 system architecture. For our first programs, we had to write all of the instructions in binary. We had to get a few projects under our belt before they gave us the luxury of an assembler.

I remember really enjoying LC-3. Not because it was a particularly fun language, but I loved learning the details of the architecture and getting to solve complex problems with fairly simple tools.

In that same intro class, we were also introduced to the classic, C:

#include<stdio.h>

int main(void) {
    printf("Hello World\n");
    return 0;
}

C is one of my favorite languages. Unfortunately, I don’t use it very often now. But I think it’s a great language to learn for the purpose of studying how computers work since a lot of nitty-gritty details are left for you to handle instead of being abstracted away.

Then, I went to C’s younger brother for my Data Structures class: C++

#include <iostream>
using namespace std;
int main() {
   cout << "Hello, World!" << endl; // This prints Hello, World!
   return 0;
}

I liked C++, but it wasn’t my favorite. I felt like there were a lot of places where the code seemed verbose when it didn’t have to be. Despite that, this class ended up being one of my favorites. The class was well structured, the lecturers were interesting, and the professors worked very hard to help everyone succeed. But best of all, all of our programming assignments ending in the creation of some neat visual which felt more gratifying than just passing test cases.

Animated UIUC I using bfs

Around that time, I also learned x86 assembly for my operating systems class.

.global  _start
.data
msg:
    .ascii "Hello, World!\n"
    len = . - msg
.text
_start:
    mov    $4,%eax
    mov    $1,%ebx
    mov    $msg,%ecx
    mov    $len,%edx
    int    $0x80
    mov    $1,%al
    mov    $0,%ebx
    int    $0x80

We used x86 and C to build a very basic operating system. This class was very rewarding, but it came with a lot of work. I came into the computer lab for the class at 5am to finish an assignment that was due at 5pm, and when I arrived there was someone who had been there for 24 hours. I ended up spending the whole day in the lab to just barely finish on time.

In my final year at college, I took two classes in system architecture. We started out by bread boarding our assignments, but that very quickly became a nightmare.

A tangle of wires

After that, we started using system verilog and an FPGA to implement our designs.

module test;
  initial
    $display("Hello World!");
endmodule

I’ve always enjoyed the hardware side of computer engineering, and getting to use an FPGA instead of bread boarding made the experience a lot better.

I’ve worked a little bit with a couple other languages in college, but that wraps up the big ones.

Now, I’m learning two languages in my spare time.

First: Java

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

I’m not particularly interested in using java, but I’m learning it as I follow along with Crafting Interpreters by Robert Nystrom. I never took a programming language class in college, so I thought it would be good to get some experience in the area.

The other language I’m learning is Swift (and SwiftUI)

print("Hello, World!")

I’m following Paul Hudson’s 100 Days of SwiftUI and so far it’s been really fun! I’m still a long way away from being able to implement the ideas I have, but I’m making steady progress.

And that sums up most of the languages that I’ve used so far. Beyond Java and Swift, I might want to start digging into web technologies more, but I feel pretty capable with the languages that I already know.

Thanks for reading!

-Alex