{ "version": "https://jsonfeed.org/version/1", "title": "Keetology", "home_page_url": "https://keetology.com", "feed_url": "https://keetology.com/feed.json", "author": { "name": "Mark \"Keeto\" Obcena" }, "description": "Keetology, a collection of thoughts and writings about code, design, and development.", "items": [ { "id": "https://keetology.com/blog/rebuilding-keetology", "url": "https://keetology.com/blog/rebuilding-keetology", "title": "Rebuilding Keetology: Static Blogging with Metalsmith", "content_html": "
One of the things that always held me back from fixing Keetology was technology. The old Keetology was always about what it was built with–and for the most part, it was always built with something shiny.
\nThe previous version was built on tech that was new at that time. It ran on a custom JavaScript MVC framework called Fineprint written for V8CGI, and all content (including comments) were stored as Markdown text on CouchDB.
\nIt was exciting when I built it, but it was also goddamn slow. The Markdown was parsed for every request, then rendered with a custom templating language. There was no caching, pages were slow to load, and CouchDB died regularly because of complicated, badly-written map-reduce jobs.
\nAnd in the excitement of building the front-facing blog, I didn’t have time to code the blogging interface. Every time I had to post something, I had to convert my Markdown into a JavaScript string that I would put in a JSON document directly into CouchDB. The effort necessary to publish anything was so huge that it is perhaps the bigger reasons I stopped blogging altogether.
\nSo when I finally decided to bring back Keetology, I decided to be lazy.
\n", "date_published": "2014-10-21T00:00:00.000Z" }, { "id": "https://keetology.com/blog/blowing-off-the-dust", "url": "https://keetology.com/blog/blowing-off-the-dust", "title": "Blowing Off the Dust", "content_html": "Keetology started out as a small Tumblr site I created in 2008, with a few collection of articles I’ve written up to fill up the site. A few months after that, I ditched Tumblr and put it on its own domain, with a brand-spanking new design and a few new articles to boot. A few redesigns after and a few successful posts later, it started gathering dust.
\nIn hindsight, Keetology was never about the blog–it was about the engine. It had its share of makeovers–maybe around half a dozen–but the stylesheets were supposed to decorate the real surprise, which is always a new blog engine powering the site. From the basic PHP “Fineprint” engine to the delightfully overcomplicated Raccoon site, Keetology’s main purpose was always to be the testing ground of frameworks.
\nSo when the experiments become less exciting and when the engine fails to amaze, what you’re left with is a site that has not been updated for years, and a feeling that you’ve done something wrong.
\n", "date_published": "2014-10-07T00:00:00.000Z" }, { "id": "https://keetology.com/blog/sondheim-meets-mootools", "url": "https://keetology.com/blog/sondheim-meets-mootools", "title": "Sondheim Meets MooTools: A Look at Company", "content_html": "A couple of weeks ago I released Company, a implicitly-mediated component system for MooTools. As mentioned in the official site, Company was created a more complete alternative to the simple event-based module systems described in my surprisingly popular Modules and Callbacks article.
\nBased on the feedback, I would say that Company was quite well received by many, although it did seem apparent that many more weren’t quite sure what exactly makes Company any better from the models described in the Modules article. Even more interesting are the comments from some detractors who not only seem to have missed the entire point of Company, but have also failed to grasp the whole background behind it’s existence by forgoing to skim through the Modules article (more on this in a bit).
\nI decided then that a blog post is in order, not just to shed light on some areas of Company but also to explain some design decisions I took while developing the library.
\n", "date_published": "2011-03-15T00:00:00.000Z" }, { "id": "https://keetology.com/blog/portablekeeto-projswithmootools", "url": "https://keetology.com/blog/portablekeeto-projswithmootools", "title": "Portable Keeto", "content_html": "Early this year I started working on a writing project somewhat connected to my favorite JavaScript framework. I decided not to announce it nor talk about it, because I know I usually fail to pull through with anything that I announce publicly. So I kept my mouth shut, and didn’t say a word.
\nThe fascinating thing about secrets, though, is that they have a tendency to come out. This secret writing project of mine therefore became “public” knowledge long before I actually announced it. There were questions, inquiries and of course, the occasional rumors. I got a lot of compliments, a few cheers and several looks of doubt. But even after all of that, I still tried to talk about the project like it’s vaporware–just to add some drama.
\nBut as fun as it has been, it’s time to let the secret spill. No, I’m not writing a book–because it’s already finished.
\n", "date_published": "2010-12-14T00:00:00.000Z" }, { "id": "https://keetology.com/blog/modules-and-callbacks-going-hollywood-with-mootools", "url": "https://keetology.com/blog/modules-and-callbacks-going-hollywood-with-mootools", "title": "Modules and Callbacks: Going Hollywood with MooTools", "content_html": "During the earlier days of the language, JavaScript played a more supporting role in application design. JavaScript was more of an afterthought: a simple way to add some effects to the page or maybe some client-side validation for forms.
\nThe recent “rediscovery” of the language, however, made a huge impact on the way we use JavaScript, and it has become the leading star for many recent applications. Client-side scripting is no longer just about adding simple effects to web pages, but has become a way to implement impressive applications that run in the browser.
\nBut as client-side applications get bigger and bigger, the code that powers them become more and more complex. Parts of the application start getting more dependent on other parts, which introduces spaghetti code filled with strong coupling between items. And the more coupling involved, the harder it is to manage applications: modifying existing functionality becomes a chore, and adding new parts becomes one step short of a nightmare.
\nAny sufficiently complex application has the risk of getting out of hand unless some sort of modular design was setup from the beginning. Designing your application to be modular isn’t a hard thing to do–although it requires some rethinking if you’re not familiar with the process.
\nIn this post, we’ll examine one way of taming complexity in applications using modules that apply the Hollywood Principle. We’ll be using MooTools here, since it’s my weapon of choice and because MooTools itself provides features that enable us to easily implement modular code. However, you can use the same ideas here with any framework you like, so long as they provide the APIs you’ll need.
\nSo if you’re up for it, let’s take a modular stroll.
\n", "date_published": "2010-10-01T00:00:00.000Z" }, { "id": "https://keetology.com/blog/up-the-moo-herd-vi-down-and-out", "url": "https://keetology.com/blog/up-the-moo-herd-vi-down-and-out", "title": "Up The Moo Herd VI: Down and Out", "content_html": "It’s the start of Keetology Week! What does this mean? Another edition of Up the Moo Herd of course!
\nWhile this was originally meant to be an article about DOM tips and tricks, the recent slew of people who have commented on how “long” my articles got to me, so I’m turning it into a shorter post about Elements
and the tricks behind common methods. I was supposed to include sections on native events and “subclassing” the Element native, but I don’t want people getting turned off due to the length of the article. Maybe I should just write a book..
Speaking of books, have you gotten yourself a copy of MooTools 1.2 Beginner’s Guide? If not, then you better get yourself one! It’s written by Jacob Gube together with my good friend Garrick Cheung. It’s packed with a lot of useful stuff and I recommend it to everyone who wants to learn (or relearn) the basics of MooTools.
\nI’d also like to thank Matti Schneider-Ghibaudo, who not only reads my blog but has also helped in making Keetology better with his bug reports.
\nAs always, the title of the post is taken from a song and this time it’s track 9 from the first studio album of the ever fantastic The Academy Is…
\nAnd with that, let’s get to know the elements of MooTools.
\n", "date_published": "2010-03-21T00:00:00.000Z" }, { "id": "https://keetology.com/blog/pahinga", "url": "https://keetology.com/blog/pahinga", "title": "Pahinga", "content_html": "I rarely write about my personal life in this blog, except maybe to add some anecdotal flavour to my posts. I try hard to keep Keetology a technical blog most of the time–a references of sorts that you’ll want to read if you want to learn more about a particular topic. However, I’m crossing into my personal life in this post for the sake of clarity and because it affects most of the things I do.
\nTo put it bluntly, I’m taking a break. I was trying to find a word to describe the break, but found the common words lacking; vacation seemed too pleasurable, sabbatical sounded as if I’m going to some far off place. And then I realized that there was a perfect word to describe it in Tagalog: pahinga. Technically, it means “rest” or “a break,” but if you ask anyone who speaks Tagalog, they’ll tell you the root word is hinga, which means “breathe.” So yes, I’m taking a break to catch my breathe.
\nAs usual, breaks in a person’s life means changes. And that my friends, is the reason for this post.
\n", "date_published": "2010-03-15T00:00:00.000Z" }, { "id": "https://keetology.com/blog/up-the-moo-herd-v-evident-utensil", "url": "https://keetology.com/blog/up-the-moo-herd-v-evident-utensil", "title": "Up The Moo Herd V: Evident Utensil", "content_html": "Howdy folks! It’s that time again when we share MooTools tips and tricks! Yes, it’s another Up The Moo Herd post, and this time we tackle those little known utility functions in MooTools. These little buggers might be short and sweet, but these functions power a bulk of the MooTools machinery, and by learning to use them you can improve your own code.
\nBefore we begin, let me apologize for the delay in the series. The past few months has been (and still is) taxing for me as I try to arrange various parts of my life. And as much as I love to keep on churning more and more posts on MooTools, I still have other priorities to consider. And yes! If you’re looking for a frontend developer or a JavaScript guy to work with, I’m available! (nudge, nudge, wink, wink).
\nAnd as in the previous two parts of this series, the title of this post is again taken from a song–this time from the debut album of Chairlift, “Does This Inspire You,” one of my favorite albums to listen to on a gloomy, rainy afternoon.
\nSo with those things said, let’s start getting useful with utility functions!
\n", "date_published": "2010-01-21T00:00:00.000Z" }, { "id": "https://keetology.com/blog/up-the-moo-herd-iv-theres-a-class-for-this", "url": "https://keetology.com/blog/up-the-moo-herd-iv-theres-a-class-for-this", "title": "Up The Moo Herd IV: There's A Class For This", "content_html": "Gather round boys and girls! It’s time for another episode of Up the Moo Herd: MooTools Tips and Tricks! In the previous installment, we talked about some of the tips and tricks involving classes. In this part, we’re gonna pick up from where we left off last time, and talk about several topics still related to classes: mutators, inheritance and mixins.
\nIn case you haven’t read the announcement post I wrote a few days ago, there will be several changes to the Moo Herd series. First, the part discussing the Fx classes will be removed and replaced by one about some DOM tips and tricks. Another change is that I removed the section on “Reusable Code” for this article due to both length concerns and because it sounded too preachy for my taste.
\nContinuing the music-flavouring from last time, this post’ title is courtesy of the second song from Cute is What We Aim For‘s first studio album, “The Same Old Blood Rush with a New Touch.”
\nAnd with that, let’s continue our exploration of Classes. Ready? Go!
\n", "date_published": "2009-10-27T00:00:00.000Z" }, { "id": "https://keetology.com/blog/up-the-moo-herd-iii-its-classy-not-classic", "url": "https://keetology.com/blog/up-the-moo-herd-iii-its-classy-not-classic", "title": "Up The Moo Herd III: It's Classy, Not Classic", "content_html": "It’s time for another episode of the Up the Moo Herd: MooTools Tips and Tricks series, where we’ll talk about classes, the backbone of MooTools. Other JS libraries thrive using plugins and extensions, but MooTools keeps its object-oriented focus by using classes and mixins to new functionality to the framework.
\nDue to length concerns, I split up the article on classes into two parts. This one tackles constructors, implement
and extend
, singletons, and private methods and variables. The next part will deal with mutators, mixins, inheritance and reusable code.
I went directly to the various tips and tricks that involve classes in this post rather than explain the basics. If you get lost, it might be good to get a firmer grasp on how classes work. The series introduction linked above contains links to tutorials and sites that would help you to do just that.
\nThe title for this post is taken from Breathe Carolina‘s second album, which I was listening to while writing this article. They’re a really awesome band, and I admire them for being able to make Miley Cyrus’ “See You Again” palatable.
\nWith that, let’s start getting classy!
\n", "date_published": "2009-07-23T00:00:00.000Z" } ] }