I Made a Maze Generation Algorithm (maybe)

Background

So to anyone who knows me (or literally just reads my blog/website) it should come as no surprise that I’m more of a PL guy than an Algo guy. I think algorithms are neat and all, I just never found them as interesting as programming languages. A programming language is something tangible that I can have fun with and interact with, algorithms exist mostly on paper. However, I decided that I can’t keep thinking like this, so over the past weekend, I locked myself in and forced myself to come up with some sort of an algorithm with no resources. Just simple trial and error with a bit of logic on the side. I ultimately settled on trying to make a maze generation algorithm since that seemed like a fairly good application for pattern matching (and I love pattern matching).

First I tried subdividing mazes into the smallest possible building blocks. While you can totally construct a maze from these, it actually didn’t help my algorithm that much. My goal was to ensure mazes were acyclic and used all possible space on the board. Using all possible mazes on a 2×2 or 3×3 grid, I was unable to find a way to stitch them together which guaranteed an acyclic and solvable maze.

Once I had come to the realization that I wasn’t going to get anywhere by building a maze with pre-made pieces, I decided to try to draw the lines in a similar way. Basically I would start at a position and try to calculate whether or not adding a line would make any other tile unreachable. While this would theoretically work, when trying this out on paper, it turned really cumbersome on any maze greater than 3×3 tiles. Since each line involves iterating over every tile in the maze, this algorithm would balloon really fast. It also tended to produce very similar looking mazes and had no guarantees about being acyclic.

Finally I came to the algorithm I am presenting here. It is quite simple and lends itself well to pattern matching. I am not sure if this algorithm exists, I still have not looked up any maze generator algorithms and will not I am certain I cannot improve my algorithm any more. If this is a case of parallel evolution, that’s pretty neat (don’t tell me about it too 🙃). If not, I would like this algorithm to be called “McKinley’s algorithm” mostly so my namesake algorithm can be something completely useless 😜.

The Algorithm

This algorithm relies on tracking the number of possible connections a maze tile can have. Connections are defined as any edge which doesn’t have a line. Therefore a tile with no edges has 4 connections, one line has 3 connections, two lines has 2 connections, and three lines has 1 connection. There is no possible tile that can have 0 connections.

This algorithm relies on reducing the value of these connections which is anologous to placing a wall between two adjacent tiles. There, however, are a number of cases where reducing the value of a connection would lead to parts of the maze becoming unreachable or connections reaching 0. Once a tile is irreducible, no further action can be taken on it, so it is in effect finished with the algorithm. For the sake of demonstration, we will denote any irreducible tile with the “Δ” symbol (arbitrarily chosen because I know it will make math people mad). The following are rules for a given tile to transition to irreducible:

  • A tile with 1 connection is always Δ.
  • A tile with 2 connections is Δ iff 1 or more of its connections is Δ.
  • A tile with 3 connections is Δ iff 2 or more of its connections are Δ.
  • A tile with 4 connections is Δ iff 3 or more of its connections are Δ.

To begin the algorithm, begin by writing a grid of tiles. The width and height of this grid must be at minimum 2×2. All tiles should start with a connection value of 4, indicating that the tiles have no walls drawn. The following is an example of a starting grid:

4 44
444
444

Next update connection values to indicate the walls of the maze on the outside. This is as simple as subtracting 1 from the connections on edges and 2 on corners. This indicates that one of the possible connections (one which would lead us outside of the maze bounds) is invalid, therefore we are unable to use it. Our starting grid would look as follows after we add our borders:

232
343
232

Next we pick a random tile from our grid. For this example, we will pick the top left tile. We then pick a random connection. For this example, we will pick the center left tile. We subtract 1 from both connections indicating that we have drawn a wall between the two tiles. The following is our outcome:

132
243
232

Next we examine the values which we just changed. Since 1 is always Δ, we update our grid to reflect that. After updating 1 to Δ, we look to its current connections. Its only connection is a 3 in the top middle position. Since 3 is only Δ when 2 or more of its connections are Δ, we do not update the 3 to Δ. Next we change our focus to the other tile we updated in the previous step. 2 is only Δ iff 1 or more of its connections is Δ. Since 4 and 2 are not Δ, we do not update the center left tile. The resulting grid is now:

Δ32
243
232

Next, let’s pick the top center tile and place a wall between it and the center tile, the following would be our grid after adding that wall:

Δ22
233
232

Now when we examine our tiles to see what we can change to Δ, we notice something interesting. Since 2 is Δ when 1 or more of its connections is Δ, and this holds true, our top center tile becomes Δ. However, the top right tile is also 2, and now also has 1 or more connection which is Δ, so it will also become Δ. This process will continue on until we hit the center right tile. Since that tile has 3 connections, and only one of those connections is Δ, it does not become Δ. Next, looking to the center tile, the 3 there also does not become Δ since it does not fit the requirements. The following is the outcome of this:

ΔΔΔ
233
232

Now let’s pick the center right tile. Notice one of its connections is Δ, this means we cannot sever this connection. In effect we only have two connections we could cut between. For this example we’ll pick the bottom right tile. After adding the wall and updating Δ, we are left with this:

ΔΔΔ
23Δ
23Δ

The algorithm finishes once all tiles are Δ, which will result in the finished acyclic maze. Since we have not hit this stage yet, we still have some work to do. Let’s next place a wall between our center tile and the center left tile. This will result in this grid:

ΔΔΔ
Δ|ΔΔ
ΔΔΔ

Notice, all of our tiles have now flipped. This indicates that our maze is complete. Drawing it out with text gives us this rather boring but valid maze:

+---+---+---+
|           |
+---+---+   +
|   |       |
+   +   +---+
|           |
+---+---+---+

To add the start and end, simply pick one of the tiles on the edge and remove a wall. This is done separate to the algorithm because when it was factored in, it would either require Δ tiles be placed outside the bounds of the maze to ensure the start or end would not be closed off accidentally. This was more trouble that it was worth, so I just opted to pick random edge tiles after the maze is complete. The following could be our completed maze with a proper start and end:

      +---+---+---+
START             |
      +---+---+   +
END       |       |
      +   +   +---+
      |           |
      +---+---+---+

And thus the algorithm is finished. I am not sure if this algorithm exists already. I would not be surprised given how simple it is, although I feel like it was probably done in a much better way 😁. If anyone can find any holes in this algorithm, please drop a comment, I would be happy to know how wrong I am (or I guess how much of an unintended plagiarist I am too).

Posted in Programming | Tagged | Leave a comment

Never forget who you are…

λx.x

(Side note: I’m really debating whether or not to get this tattooed on my forehead when I inevitably start my lambda cult…)

Posted in Misc | Tagged | Leave a comment

Achieving enlightenment

sudo apt install enlightenment

🙂

Posted in Linux | Tagged , | Leave a comment

On credit, attribution, and ownership

Over the past few months, I’ve found myself questioning more and more of my previous beliefs I’ve held for so long. This is due in part to taking Software Development with Matthias Felleisen, but also partly just because I’ve hit the point in my life where everything starts to get real. One of the major topics I’ve thought about is my opinion on attaching my name to everything I’ve created.

When I was younger, I used to think attribution was everything. I always insisted on being credited for every little contribution I would ever make. I vividly remember making sprites for a friend’s game, and demanded I get put in the credits, despite making maybe like 1 or 2 things. I also remember making one of my friends put the entire text of the GNU GPL 3.0 license in his CSS style sheet because I wrote it for him. I also was very strict on supposed “copyright infringement.” I recall berating one of my friends because he had the gall to as so much as take inspiration from my choice of colors on my homepage.

Thanks to Software Development, I had been introduced to the concept of egoless programming, which immediately struck a chord with me. Egoless programming effectively separates the programmer from the program. For example, egoless programming would ask “why does the code do this?” instead of “why did you do this?” This idea made me reconsider why I write code. I have no motivations of fame or wealth or even adoption, I just make something that I think is cool and want to share it with anyone else who thinks it might be cool. If this is my sole reason for creating something, why should I attach my name to it. So people later down the road can go “Oh, this Collin guy made this cool thing?” Not exactly something I care about. I genuinely do not care about any sort of fame or recognition I would get from being the guy that creates the new cool thing, just creating the new cool thing is reward enough for me.

Another thing pushing me away from the idea of attaching my name to everything I’ve done is just looking at the other people (including my old self) who do it. I have seen internet wars erupt over “trademark disputes” or people attaching credit onto the stupidest of things. Over two years ago, I helped one of my friends make a quick poster for his band. I used to work as a graphic designer, and tend to do work like that as a hobby, so I graciously agreed. The design itself was super basic, just 5 basic Keith-Haring-esque people standing in front of a basic sun and sky with two massive speakers to each side. I really liked the design, and was super stoked that they decided to use it. Flash forward to now, and they use it for everything. The credit to me has also been lost in translation. At some point, the band members started crediting my friend with having made it, and that credit continues to this day. I realized this when viewing their Instagram page and seeing that my friend was credited in the description with having made it. I was going to send a message and go “hey… I actually made this”, but in that moment, I stopped and thought about what a simple shout-out in the description really means. Maybe one or two people would drop by my unrelated Instagram page. Maybe one person would go “hmm… I’ll remember that name”, but ultimately, nothing in the grand scheme of things would happen. Its a single image on a social media platform I don’t even like to use. The fact though that they are still using the design I made for them so long ago is humbling to say the least, even if I’m the only one who knows it.

Going forward, I am not sure what I will do. I may begin releasing some of my works into the public domain. I may begin to isolate, and develop things only for me, not caring about the wider world. I am not sure. At the end of the day, a name on a page is merely a grain of sand in the vast desert that is our timeline. To realize this is to be freed from the burden of trying to inform everyone that it is there.

This entire post was inspired by a name being accredited for a website which is designed to act as a collective for a group. I will not name names, but those who know will know.

Posted in Misc, Programming | Tagged , | Leave a comment

JavaScript’s “history” methods are cool

Recently, I was writing a paper which required me to do a little historical background research. Through this I ended up on the website for Encyclopedia Britannica. As I was scrolling the page, I saw something that I hadn’t seen before. As you infinite scrolled down the content page, the URL bar at the top of your browser would update to reflect what section you are in. All of this was done seamlessly without refreshing the browser or anything.

Now, I had seen similar things like this using full page transitions. I had always assumed it was a function of caching or otherwise, but it turns out, its a built in JavaScript method. One that is pretty damn cool.

The methods in question are history.replaceState and history.pushState. history.replaceState , like the name implies, replaces the whole URL with a new one and does not generate a “back” state for you to return to when you hit the back button. If a user was scrolling a page, a website could use this to update a section link as the user scrolled. history.pushState is a little more interesting, it creates a new history entry and replaces the URL with a new one. This means the back button still functions, and will return you to the previous URL, which also won’t reload the page. This means you could have a whole website that only really loads an entire page once, and just fetches and renders content, and the user would have the same experience as a traditional website.

If you want to see this in action, try the following code snippets on any website:

history.replaceState(null, "Title", "/fakeURL");
history.pushState(null, "Other Title", "/hitTheBackButton");

If this is combined with a listener for the “navigate” event, a full website’s navigation could happen without a reload at all, which is very neat. An example of that could be as follows:

window.navigation.addEventListener("navigate", (e) => {
    // fetch content here
})

I may try to screw around with this in the future, but for now, it can live here. If anyone implements a website using something like this, or knows one that does, please email it to me or drop a comment, I’d be very interested to see it in the wild.

Posted in Programming | Tagged , , | 1 Comment

The strange case of the Gopher “i” type

I finally feel like making another blog post! This marks the first for 2024! Crazy!

If you haven’t heard of Gopher before, you aren’t alone. Gopher competed against FTP and HTTP during the race for the web, and as you can guess, lost. Gopher is an interesting hybrid between the two. Like ftp, it is designed primarily to share files and organize itself like a directory, but unlike HTTP, it offers no markup language to make descriptive pages. Gopher instead decides to send a single character before the name of the file, this character denoting the type. They range from 0 as “text file”, to 7 as “request for text query”, to more modern additions like I for “image” and are always treated as links. There is one item type that stands out though, and that is the i selector.

i is a nonstandard item type which was added to Gopher’s common vernacular at some point between its inception and the current year. It is not specified in the RFC, but is unanimous enough to get a spot on the Wikipedia page. It has become one of the most widely used item types and appears on most modern Gopher sites, including my own. It stands out from the other item types however, as its not meant to be displayed as a link, but rather a line of standard text. This makes it very confusing as to where it fits into Gopher as a whole.

HTTP is a protocol about sharing files and documents, however somewhere along the way, it became a platform in its own right. The days of serving static documents over the wire has given way to fully fledged applications running over what amounts to a network connected virtual machine. A program capable of downloading and running code from anywhere, and doing so in a (mostly) platform agnostic manner. With its meteoric rise and ever expanding feature set, many people have decided to go back and give Gopher another shot. These people however, intentionally or not, are bringing HTTP habits with them.

If you look at any Gopher site created in the early days of the protocol, you’ll notice something. It effectively acts as just a public FTP service. You are simply presented with a file index and a list of files and directories. Despite this, like on FTP, people still hosted informational content, programs for download, and a facsimile of what would become blog posts. To view these files, one would simply download it to their computer, and open it with a dedicated viewer.

If you juxtapose that to a modern Gopher site, created within the last 10 years, one thing will stand out almost immediately. The mixing of content with directory listings. Just like HTTP has evolved in its time, Gopher has also evolved and changed, and this change has fundamentally altered how Gopher sites look and act. If one navigates to a Gopher site now, they are able to read information and follow links directly under or above them. They are able to see a message of the day, or a brief introduction to what is stored in a directory. Gone are the days of “README.txt”, presenting information to the user is now easier and more commonplace. This is partially the reason for the i item type’s widespread popularity, it is a really useful tool.

The i item type’s use however, varies from site to site. As of recent, I’ve noticed an uptick in sites using the i item type in place of a traditional text file for relaying information. This is an interesting change for multiple reasons. Traditionally, Gopher relied on the client just for getting files, not viewing them. When HTTP became the universal protocol, most browsers implemented some way to view various files in the browser, and suddenly it became a requirement to read text files in a browser. When many went from HTTP to Gopher, they seemingly brought this sentiment with them, and would rather have the client display their information than rely on a client to download and read it.

Another interesting idea becoming common place in Gopher is adding links to text content pages. Gopher has no concept of a “page”. Instead of a page, when you view a Gopher site, you are viewing a “Directory”, functionally no different than typing “ls” in FTP. Any other item type is simply a file or redirection to another service (or in the case of item type 7, a request to a directory). The introduction of the i item type allowed directories to suddenly start acting as files, but with more features. In a directory, you can link somewhere; in a text file, you can’t. Some modern Gopher blogs I’ve seen completely forego the humble text file all together, opting instead to use directories for posts since they can curate a collection of clickable hyperlinks, or even just to have the option to do so. Now what would traditionally be a directory listing has turned into a pseudo-document-markup-language, an interesting shift.

This of course begs the question “is this a good idea?” The only major downside of doing this is just that older Gopher clients won’t be able to render your page. Anything from Internet Explorer 6 to NCSA Mosaic will think your page is full of broken directory links, since they predated the i item type. However, modern Gopher browsers like lynx or even Firefox 3.5 can display i types just fine. The most interesting dilemma is simply “is this intended?” On one side, the i type has become the second most used item type, therefore it has cemented itself in the protocol. On the other, Gopher is a protocol for sharing files, writing blog posts in it is not intended behavior. If we stick to intention to dictate what we do with a protocol however, most of modern HTTP would need to be thrown out, since HTTP was designed to serve documents, not applications.

In my humble opinion, the Gopher “i” type is alright. I like and use it actively. In my eyes, it acts more like an FTP server’s MOTD, or Message Of The Day, than a markup language, but it is very helpful for demarcating sections of files, or introducing a common theme they have. However, I also see the limitations of this item type. I do sometimes use older browsers on older systems, and Gopher makes a really nice transportation layer between older and newer systems, since it doesn’t use any form of encryption what so ever. These older browsers do not typically handle the i type correctly, and usually display the entire page as a mass of links. While the content is still fully readable, it suddenly becomes harder to distinguish what a real link is and what a broken i type is. For blog posts and longer form text content, I feel the simple text file is still the best option. In this way, you don’t break your content on older browsers and it remains accessible for everyone. Ultimately, I don’t care what anyone does with their Gopher site. The vast majority of people use modern Gopher browsers that can handle anything. Most modern Gopher users use it as a refuge from the modern web, but still want the mixed media features that come with it. Who’s to say they can’t use Gopher as their own mini-HTTP.

In conclusion, Gopher has lived a pretty interesting life, and with that life has come many changes. While the i type was not specified in its original RFC, it has cemented itself as one of the most widely used types. The use of this type however has seen some fundamental changes to how Gopher sites were intended to be designed. While it may not be supported historically, it has transformed Gopher from a file transfer protocol to one with a de-facto document language. A change that says more about how our use of the internet has changed more than anything.

Posted in Misc, Server | Tagged , | Leave a comment

Micro: The Crow rewrite

I am currently rewriting the core of the Crow lisp language I made. I wrote the language originally over a year ago, I tried to create a hybrid between Lisp and JavaScript, however as time went on, I slowly realized that this hybrid approach was just doing both languages badly. I have recently decided to realign Crow with Scheme, the Lisp dialect I prefer, while taking aspects of Common Lisp that I prefer to Scheme. This new core is not ready to be built or used, but it is gradually being worked on over at the Crow GitHub under the “core-rewrite” branch. If you were wondering why my site has been so quiet over the past few months… this is why…

Posted in Micro Posts | Tagged , | Leave a comment

Software I Use (And Recommend)

This started as a page for my website, but gradually grew in scope to the point where I think this deserves a blog post dedicated to it. I may also make a page for it on my site, but much more condensed with the true explanations here.

Here is a list of programs I use on a daily basis. I mostly am providing this because I have been asked before questions like “What browser is the best?” or “What IDE would you recommend for X language”, so lets compile it all into a list, shall we.

Before we begin, when it comes to software, I have changed what I look for over the years. Back in 2016, I used to be a software minimalist. Going so far as to use almost every application from the terminal if possible. Over time I found that this wasn’t sustainable for me (or really anyone who gets work done) and have gradually moved to more and more normal looking applications. Now, I generally try to use FOSS software, however I even have been slipping on that. Generally I like software that is native to my platform of choice, so I will be splitting this up by platform. I also look for software that is light weight, or at least isn’t extremely bloated for what it is, and also for software that does the job I need it to do.

Operating System

Generally my advice to other people here is to use whatever feels best to you, but here is what I use and recommend if you can’t make up your mind. Do note that I come from a perspective of someone who programs for a living, and not just that, but works on the lowest level of an operating system, so my opinions on systems will be very much biased towards features that most users probably won’t care about.

For Linux distributions, I generally recommend Debian and Ubuntu, they are both remarkably stable and I have used them for years, having started on Ubuntu in 2011 and moved to Debian for my first full-time foray into Linux in around 2015. Both have served me well for the time that I have used them. As for Linux in general, I highly recommend it for everyone, regardless of computer skill. I think Linux has become easy enough to use for the layperson, and offers a much better alternative to Microsoft Windows.

As for the OS I am currently using, I have been using MacOS for almost a year now. Since the M1 Macs have bad support for Linux as of writing this, I have been stuck on MacOS, and to be completely honest, its kinda nice. MacOS is definitely UNIX like, and pretty faithful at that being based on BSD. I have found absolutely no issue porting my workflow over to MacOS other than the issue with some packages not being available for ARM64. I’m looking at you Valgrind. To be completely honest though, I see MacOS get a lot of hate from people in the programming community and I struggle to see why. MacOS is basically just a Linux (or BSD more like, but still) distro from a corporation at the end of the day. It works fine for what I need and does the job swiftly.

I generally don’t advise using Windows since I personally have grown to hate their Win32 API, as well as their developer tools. In my opinion, Windows is a product of a bygone era, one which still clings to life thanks to business and enterprise. In my opinion as well, there has never been a ‘good’ release of windows, maybe bar the first few which were impressive for their times. While I have used Windows for a majority of my life, and do have to admit I have nostalgia for it, I can’t recommend it for use in programming. I eventually will write a blog post about how bad the Win32 API is, and especially how bad the Windows POSIX layer is.

Web Browser

Lets move from Operating System to Operating System (but this time for the web).

Now adays we have very little choice in the web browser market, basically just three engines: Blink, WebKit, and Gecko. I do actively use all three of these browser engines however, mostly just to see how different they all are, but even still I do have a few favorites (and a few ones you should avoid at all costs).

For the browser I use daily, Firefox. I have used Firefox pretty much daily since around 2015, if not earlier. I have always liked Firefox since for a while, it was the only browser that Linux could truly call its own. While Chromium did exist on the platform, dubious open source violations, as well as a confusing relation with the system theming caused it to look completely out of place among the other free software on the system. Firefox has and will probably always be the FOSS browser of choice, despite having its own FOSS violations. Apart from that, despite taking a hit with the XULpocalypse, Firefox addons continue to be more powerful than Chrome extensions in my experience, and Firefox seems to have a much better, albeit smaller community.

As for Blink based browsers, I have to give the recommendation to Chromium and/or Brave. I barely use Blink based browsers, other than to load pages which Firefox cannot, or to log into Google apps. Chromium, being the open source version of Chrome (I generally recommend Chromium with the Ungoogled Chromium patch set applied, however stock Chromium is still pretty good), it does the job wonderfully for browsing the web. Brave is a little weird. While I want to like it, I can’t actually push myself to use it. It is simply a Chromium reskin, with a lot of Crypto integration sprinkled on top. I do not trade in crypto, nor do I use it in any capacity, so most of what makes Brave unique is completely lost on me. Likewise, Brave is a little annoying with how bloated it is becoming, with the integration of many extensions into the browser core itself. Every time I boot up Brave, which is generally not often, I am barraged with popups asking me if I want to enable or disable this new feature, along with sometimes multiple new icons appearing on the toolbar. However despite all of this, Brave is an amazing browser in terms of speed and privacy. I highly recommend it as probably one of the better Chromium based browsers if you don’t want to use Firefox. And it is the browser I use and recommend for iOS as well.

As for WebKit, there aren’t many options, and in general I don’t recommend them at all other than for testing. While Safari is cool, many modern websites won’t work with it, and likewise it is completely proprietary, although the web engine that powers it is not. Epiphany (gnome-web) is also nice, but suffers from a horrible rendering pipeline which causes the simple act of scrolling to be incredibly laggy, despite the browser actually loading and rendering pages extremely fast compared to other browsers. If you absolutely have to use WebKit, just use which ever browser is most compatible on your system. Oh, and do NOT use QtWebKit, it has been abandoned for years.

As an honorable mention, Pale Moon, which is based on a fork of Gecko called Goanna. Pale Moon is an awesome browser for if you need light-weight and powerful. Pale Moon was forked from Firefox before the XULpocalypse, so it retains the classic XUL extensions and platform, giving much more freedom to the user. However sadly Pale Moon has struggled to keep up with the ever changing web landscape, meaning many sites are completely broken in it. Despite this, development continues on, and just recently, full support for Google WebComponents was added, making it much more compatible with the web as a whole. I’d say check it out, but you probably won’t do much with it.

Text Editor / IDE

Emacs. Done.

Well seriously, I mostly only use Emacs for its Lisp interpreter, but it is still fun to say that’s all I use.

As for the Text Editor / IDE debate, I generally say use an IDE where it makes things more convenient, for example when working with Java or C, but a text editor when nothing really matters, for example with HTML or JavaScript.

For IDEs, I have to recommend XCode if you use MacOS. XCode is really light weight and fast in my experience. It works well too with llvm. That’s about all I can say however. I haven’t used it for much more than compiler development.

For text editors, I recommend Geany on Linux. Geany is amazing if you use Gnome or a GTK desktop. Geany works with many languages, and even integrates nicely with GNU Make. Geany however is terrible on MacOS and Windows just because GTK is not great on other platforms, and better alternatives exist.

For Windows, I recommend Notepad++. While I haven’t written code in Notepad++ is well over 5 years, I remember it being nice.

Otherwise for cross platform, use VSCodium. Its a fork of VSCode that removes some telemetry and other proprietary components. Its pretty good all things considered.

Compilers and Programming Languages

For C, gcc or clang are fairly similar, I use them interchangably. They are both amazing.

For Java, OpenJDK.

For Lisp, Scheme, particularly Guile. Racket is nice too.

Generally I program mostly in C, but for scripts and other small projects, I’m known to work in Ruby and Lisp. Most of my web apps are written in JavaScript as well, although I haven’t written one of those in a while.

Instant Messengers / Chat

For IRC, Limechat on MacOS, HexChat on Windows and Linux.

For Telegram, just use the official client.

For XMPP, Dino.

Generally I recommend IRC and XMPP for people, but I have found myself unable to leave Telegram just because of history with the platform. Telegram is horrible and people should not use it. Signal is also a nice alternative, although a bit more limited.

Media Player

VLC or MPV, depends on the type of media.

Games

I don’t really play games anymore. Just put this here to say avoid steam like the plague. Use GOG.com wherever you can.

To be continued…

If you can’t tell by how short these paragraphs are becoming, I really don’t have much to say about much other software besides the ones I talked about so far. Expect this list to be updated when I find other software I need to talk about, or maybe another blog post made about it.

Posted in Misc | Tagged | Leave a comment

Micro: Just an update

Holy crap, this has been a busy year, and we aren’t even half way through it. I have been here even though I haven’t made a single post since new years (sorry). So where has the time gone? Let’s talk about it…

First of all, Crow is progressing well. In fact crow is now much more fully featured than when I last talked about it, and steadily improving. Many of the hack-jobs like the variable system have steadily been replaced by much more robust systems like the closure system. These systems have given way to a multitude of features like lambdas. Next big project to tackle is overhauling the horrible garbage collector which has pretty much remained unchanged from the beginning. Documentation is also steadily being produced, hopefully by the end of the month, crow will be fully documented, and have a fully featured tutorial!

On a side note, I have also been working with Linux kernel development in my spare time. Mostly to create a project I’m calling CrowOS which would basically be an entirely different kernel, just basing on Linux for driver support. In doing so I have learned many things about how the kernel works, how to build a truly minimal one, and even how to develop and hack on kernel modules. I want to make a kernel module development series on this blog since kmod development isn’t very easily documented in tutorial form, probably for good reason, but I want to change that :).

Anyway, keep a close watch on both this blog and the Crow project, I will hopefully be back to posting more regularly soon.

Posted in Micro Posts | Tagged , , | Leave a comment

Micro: First!

So uh… This is the first post of the year I guess. I’m making it my goal to write a lot more this year, and probably add more interesting stuff to my website. Already I got my website working with a generator I wrote, so adding to my site is now easier than ever, and updating it is just as easy. As well as that, I have backed up the entire html directory and will begin pruning old services nobody uses in order to not only save space, but make everything more manageable.

Basically this is the year of cleaning up and streamlining.

Posted in Meta Posts, Micro Posts | Tagged | Leave a comment