Bitcoin’s block times

Just this week Bitcoin has reached a consensus in regards to the scaling issues it’s been experiencing. This isn’t something that hasn’t been foreseen for quite some time, nearly 2 years actually. The issue is a bit complex and I don’t wish to dig into all the details. If you’re interested, you can read more about it. However, to give this article some groundwork, I’ll recap the primary issue.

In recent months, the number of unconfirmed transactions on Bitcoin’s blockchain have skyrocketed. That’s the number of transactions that have been placed on blockchain that have not been confirmed by miners. The reason this has happened is because there are a limited number of transactions that can fit into a 10 minute block. Only the transactions paying the highest fees are getting confirmed in a reasonable amount of time. There are multiple solutions that have been presented to address this issue. However, like any ecosystem, changes don’t come without compromise - this isn’t any exception. The consensus reached this week will increase the blocksize to 2MB. That’s great, this will allow for more transactions to be processed within a 10 minute block time.

Now, you may be asking yourself, why would this be an issue. Well, in order for people to get Bitcoin transactions processed in a reasonable amount of time, people were paying higher transaction fees. The result of this was massive profits for miners. An increased block size will decrease the amount of profits miners will see, initially, since it would essentially increase throughput, thereby decreasing the transaction fee required to get a transaction confirmed within a reasonsable amount of time.

This issue and the lack of a consensus to date has led to a lot of uncertainty surrounding Bitcoin. You may not have realized it, especially given the growth Bitcoin has seen in recent weeks. However, it’s been there and evident.

Ethereum’s Casper algorithm

Let’s talk about another blockchain mainstay, Ethereum. Ethereum is facing similar uncertainty at the moment that’s currently damaging it’s position. This can be seen through Ethereum Classic’s recent increase in demand. The issue with Ethereum is similar in some ways, but actually quite different. Ethereum is also facing scaling issues, especially looking to the future, and a lot of talk has been had about this issue. The Ethereum team has a working solution to this problem in the form of POS (proof of stake) with their Casper algorithm.

Ethereum is currently a POW (proof of work) consensus blockchain. The difference between POS and POW is, tied to how transactions reach consensus. Again, the issue lies with the current network’s miners. With POW, miners are currently netting 15x their daily mining overhead. Why would they want to give up these profits with a POS consensus? POS solves the scaling issue, but severely hurts mining profits, favoring stake holders - those that hold more ETH as a validator.

As a result of this inevitable move, the miners of Ethereum, are putting up a fight. This could lead to another phantom Ethereum chain, or the resurgence of the Ethereum Classic chain. Regardless of what happens here, we’re just creating more fragmentation and confusion in the ecosystem. Keeping up with these forks and variations is difficult and complex - impossiblef for some.

I’m not going to go into the economics and game theory of POS and how this is going to bring in major institutional capital, in a potentially unhealthy way, that damages the overall distributed nature and consensus model. This is far too speculative and complex of a topic for this article, but very much an interest of mine - maybe another article.

The politics behind it all

All of this is said to draw light to an underlying issue within the greater blockchain ecosystem. There have been countless other examples of these types of issues with other blockchains. However, they haven’t been in the lime light as much and haven’t had the impact on the greater blockchain ecosystem as these have. There will be more of these in the months and years to come. Additionally, I feel the apex of one of these issues will present the first real setback the blockchain ecosystem will see. The kind of setback that will have people second guessing the viability of blockchains as mainstream solutions to our current centralization challenges.

You see, when issues arrise, you have two camps that disagree on the direction forward. In the end, the two camps either split ways, or there is a consensus.

In the case of splitting ways, you have fragmentation of the ecossytem, general uncertainty, less focused resources and overall confusion.

In the case of a consensus, buy-in is generally fairly political and involves the major players. In the case of Bitcoin’s recent consensus to move to a 2MB block size, the decision came after gathering the support of, some, 80% of the network’s hashing power. This 80% comes from a very small number of entities. It’s already bad enough that 80% of the network’s hashing power comes from so few entities. But, even worse, is the ability of these entities to dictate the direction and decisions for the network.

Blockchains, distributed trustless consensus ledgers, were designed to break free from the types of influence/power a select minority of entites and individuals had over currencies and assets, both through verification and politics. This was one of the main designing principals. There are many other benefits as well, but this is what gave rise to blockchain popularity.

The issue that we face today and will see much more of in the future, isn’t much different from the issues we have in any typical democratic government. Many discussions have been had about this and governance in general. There are various DOAs (Decentralized Autonomous Organizations) currently trying to address this issue through programmatic and interventive means. Whether or not any of these projects prove to be successful in discovering a solution to true democratic consensus is to be seen. I have my doubts.

Personally, I don’t really wish to promote or advocate for a DAO, or DAO like implementations on top of current blockchains, especially those we have today. What I do wish to bring attention to, is the need for a general governance model built into any new or existing blockchain.

The governance model

What this means is, any new or existing blockchain, including Ethereum and Bitcoin, need to develop, in the general sense, an agreement, processes and plans for resolving these issues that allow for consensus to be achieved through a clearly stated process. This process should be dependent on the blockchain and it’s own unique ecosystem requirements. By doing so, users and participants of a blockchain are agreeing before hand to be a part of an ecosystem with a governance model designed to resolve any future issues.

Without this, we’re subject to the current state of political jockeying and power plays where a select minority of individuals and entities call the shots, generally in their best interest. And where consensus isn’t able to be reached, forks happen, fragmenting the ecosystem and delivering uncertainty.

A governance model, not only addresses how to handle these issues, but also lays a foundation that provides comfort for participants, even when a decision is made that they do not necessary agree. Therefore, it’s in the best interest of all blockchains to implement these processes, so as to avoid fragmentation, uncertainty, and overall blockchain distrust.

It doesn’t have to be overly complex or difficult. In fact, it should be very clearly understood and promoted, almost like an “about us” page for a company website. It should lay out the processes and proceedures for resolving any conflicts that might arise within an ecosystem. Every ecosystem is going to be different, as will the requirements. It could be as simple as pro-rata based voting, or a model like Steem’s witness elections. Regardless of the approach taken, all blockchains should be held responsible for providing this clarity.

I originally moved to Wordpress because of the flexibility and simplicity of getting up and running. The benefits are all pretty clear. However, the thing that always irked me was the hosting requirement. Having run a hosting company previously, and wanting to have the ability to fix issues as they arise, should that become necessary, I couldn’t bring myself to use shared hosting, despite doing it at one point. Because of that, I was left with no other option than to maintain my own server, a VPS, EC2 instance to be exact. I’ve been doing that for at least a few years now. It’s been mostly hassle free, but just having it and knowing I’m going to have to deal with it sometimes is enough of an annoyance.

That’s why I’ve made the leap away from Wordpress and to a static site. I’m using Hexo, a Node.js driven static site generator. I’m still learning some things, but overall it’s been pretty good, flexible enough and simple enough. I wanted something written in Javascript for a number of reasons that I won’t get into here, but Hexo seems to fit the bill quite well.

And that’s about enough for this first post. I still have to migrate over all my old content and reason with the site design a bit more. Hopefully I can find the time to do all this soon. :)

That said, I want to talk about TPP, the Trans-Pacific Partnership.

Firstly, I don’t agree with Obama on many issues.  I don’t really need to go into all the ones he’s made and positions with which he’s stood, for which I disagree, but they’re often and many.  Despite that, Obama’s stance on TPP and the fast-track need is the first time I’ve truly felt that he’s left his idealism behind, researched and consulted and made a very tough and bold stance.

Now, you could say he’s made many tough and bold stances before, and you would be correct in that argument.  However, he’s never really made a stance where the majority of the Democratic party and his own caucus disagree.  And, for that, I applaud him, and respect him as president much more.  That’s not an easy thing to do and the way he’s gone about the TPP shows serious maturity.

So, about TPP.  It’s going to kill your job!  Sound the alarm!  The sky is going to fall!

It is actually going to kill your job though.  Really, it will.  But that’s okay.  Yep, that’s okay.  It’s not okay in that, you need to lose your job and all is going to be peaches and roses, okay.  It’s okay in that, we’ll still move forward as a country, and you’ll come along as well.

If you’ve been watching things closely, you’ll know that the house just struck down the proposed “Trade Adjustment Assistance” bill.  The purpose of this bill was to provide assistance for you because you’re going to lose your job.  Spearheaded by Nancy Peloci, house democrats defeated the bill with an astonishing 126-302 vote.

Its defeat is the only way we will be able to slow down fast track... [and] ...people would rather have a job than assistance

Why would a president intentionally put forward a bill that’s going to kill your job and then take tax payer’s hard earned dollars and start handing it out to you as pity money?  How does that make sense?

Well, it makes sense in a very real and very scary way.  You just have to actually think a little harder and actually consult and research the topic.  You also have to have some foresight and a desire to want America to remain the most prosperous country on the planet.  You’ll still lose your job though!

Even though you’re going to lose your job and get a pity check in the mail, you’re going to be better off.  Why?  Not because socialism is amazing.  And yes, it’s absolutely a step towards socialism.  But, because you’re going to lose your job anyway.  So why not at least get a check?!

TPP is all about China!  Here is the skinny.

It shouldn’t come as a surprise to you that much of Asia is poised for tremendous growth over the coming decades.  And, when I say tremendous, I mean tremendous.  There are over 10x as many people in Asia as there are in the US.  So, the growth that the US has seen in the past decades, multiply this many many times over.  That’s big, it’s happening and it’s happening with or without the US.

The reason TPP is all about China is because, if the US doesn’t create a free trade deal with all of the countries in Asia to capitalize on this tremendous growth, China will.  China is already geographically and industrially poised to capitalize on this growth, and without a free trade deal with the US, most US companies won’t be able to compete and will lose out on one of the biggest economic opportunities of our lifetime.

Someone has to supply these developing countries with all the supplies needed for their rapid expansion.  This is everything from nuclear power expertise and products to airplanes, cars, and software.  If the US isn’t able to compete by supplying these needed products and services, China will.

Not only is that lost opportunity that would convert to massive tax revenue for the US from company profits, but it also means that China will be able to improve their industries within the market segments that are the most profitable and valuable - the highly specialized markets.  Then, years after they’ve been able to do this, the US is stuck trying to compete with China, not only on manufacturing as we’re doing today, but also on the highly specialized products and services we dominate today.  This would leave the US struggling to remain the most prosperous country in the world, as we compete constantly for trade around the world - not just in Asia.

The depth of all this goes much deeper.  I didn’t even mention the allied axis advantages that could be created from trade partnerships like this.  If TPP doesn’t happen and China becomes the major partner for all of Asia, there is a strength created there that the US wouldn’t be able to break.  China hasn’t exactly been the largest supporter of free speech and human rights either.  From a US and humanity perspective, that’s not a powerhouse alliance desired to be seen.

However, if it does happen, and China gains more specialized industry on top of improved manufacturing, the company you’re working for now with your precious job, isn’t going to be able to pay you nearly what you’re making today, they’ll be competing in an entirely different world.  You’ll lose your job!

So, why not play ball?!  Let’s continue to own the profitable expertise industries and manufacturing, the companies that generate the lion’s share of profits, and reap the rewards as a country.  You’ll lose your job, our powerhouse companies will make mega profits, pay mega taxes, and as a country we’ll be mega wealthy.  In the meantime, you can take that pity check and buy yourself a piece of ownership in these powerhouse companies, or you can sit back and wait to lose your job and cry about it later!

UPDATE - Jun 13, 2015:

The Whitehouse and Obama just released a new “Weekly Address”, urging for support on the new trade bill.  There are certainly some pieces in there to try and appeal to his base, but the message is clear and on point.

I’m honestly not on the gluten train yet and not sure I will be, but this has now become much more top of mind for me as the results are certainly not pleasant.  I’d like more info/research/data on this.

It’s been a while, about 4 years - give or take, since I’ve invited Foxy back into my daily computing life.  I began using Firefox sometime before their famous 2 full-page ad in 2004.  That put me with using Firefox for about 6 years before abandoning it in favor of Chrome.

The original reason for my departure from Firefox came down to understandable bloat.  As Firefox began to mature over those 6 years, they added some necessary and amazing functionality to their new trailblazing browser.  Firefox had best-in-class developer tools and a clean user interface, they subscribed to W3C standards support and were firmly focused on earning users’ continued use.  It wasn’t that, when I dropped Firefox around 2010, it wasn’t a nice browser and they’d changed the ethos that’d initially drawn me to .  It was more of a growing pains scenario that any software product is going to face during such a heavy feature implementation phase.  To be honest, I stuck with Firefox much longer than many other colleagues at the time.  And, this was mostly because of the developer tools and how they’d fit into my workflow.

Switching to Chrome, at that time, was a liberating experience.  Remember that Flash was still very heavily used around 2010, and was the culprit more times than not to a browser slowing down and/or crashing.  Moving to Chrome, I no longer had to worry about the entire browser crashing because some kid wrote a bad flash app, causing me to lose all my tabs and completely “brake” my workflow.  Chrome also came with a clean UI that took a fresh approach to the modern browser - that universal address bar and unified application view (no top bar for close, minimize, maximize icons).  The real kicker though that kept me on Chrome was the speed increase.  It certainly didn’t hurt that the entire browser didn’t crash once a day, but that speed was the big sell.

It took me a while to get use to Chrome’s developer tools.  I certainly yearned for Firefox’s CSS inspection, it blew Chrome’s out of the water.  However, the Javascript inspection and network analysis tools of Chrome opened my mind to what it was everyone had been raving.  Firefox really couldn’t hold a match to these tools.  I certainly would credit Chrome’s Javascript inspection tools for accelerating the inevitable growth of the UI as we know it today.  Without these tools, developing highly complex Javascript frontend applications is extremely challenging.  And so, I’ve stuck with Chrome ever since.

As of the last year or so, I’ve been hearing more people talk about switching to Firefox.  “Firefox is a lot faster”, they’d say.  I just chalked that up to them being Firefox fanboys, Linux users, or “Google is evil” believers.  “It’s unfounded” I’d tell myself.  Then I’d pull out my version of Firefox and load a few sites, proving to myself that was correct.  “Yep, it’s still the same bloated Firefox, although they’ve made a few smaller improvements with the UI finally”, I’d conclude before getting back to work.

Just the other day, Firefox released a whole new browser version focused at developers, Firefox Developer Edition.  It’s a smart move, going back to their roots and looking at the history of browser success.  Gaining the devoted use of developers is a surefire way to gain market-share, something Firefox desperately needs in the dichotomic desktop ecosystem.  Developers are not only a highly-trusted resource of tech information for those around them, which leads to recommendations for their favorite browser, but also, when applications are developed and tested on a certain browser other things tend to follow, such as useful plugins, end-user adoption, and more.  It’s certainly a smart move, and one that I predict will prove rewarding.

So, naturally, I gave the new Firefox Developer Edition a go.  As I’m sure you’re aware by the title of this article, I am enjoying it.  But, I didn’t go into it with high hopes.  I downloaded the new version, installed and loaded it up, noticed the new UI - wasn’t all that impressed, and loaded RentPost.  That was the wow factor!  It was as if the page was already cached.  I swear, my first thought was, “did Firefox just dig into my Chrome cache”.  I loaded up a few more webpages, ones that are typically pretty slow, news sites, and sure enough, they were almost as speedy.  Color me impressed.

[caption id=”attachment_209” align=”aligncenter” width=”700”] Most of the site loaded in around 1 second. The one long process was a request for an RSS feed for the footer and the others are mostly 3rd party assets.[/caption]

After my opinion started to sway towards, “I might actually be able to use this again”, I began to dig into the UI settings to try and “fix” some of the things I can’t live with.  Firstly, I don’t need a black themed browser, fixed.  Next, what’s up with all these icons to the right of the search bar, Firefox Hello, although interesting, I certainly don’t need.  That got cleaned up.  Then, there was the shining beacon of goodness right before my eyes, the ability to drag the search bar into the unused bin of modules.  Score!  The UI actually looks nice now.  This is something with which I can live.

There is still more to go in terms of putting the browser through it’s tests.  I’ve only been on it for less than a day, but I’m now over all the initial hurdles keeping me from moving forward, all signs pointing towards a full switch.  I’m actually looking forward to keeping Firefox as my default browser.  I do appreciate their ethos and I’ve seen a few nuggets spread throughout the settings that tell me they’re focus is in the right place.

So, Foxy, let’s do this!

UPDATE

Also, the docs on the developer tools are helpful as well.

UPDATE 2

I plead with the Firefox team to focus their efforts here as, at least for me, this is the one thing holding me back.  I can live with the other smaller quirks like page reflow and repaint jitters, in particular with scrolling.  God speed!

UPDATE 3

I’ll continue using and will update with any additional feedback.

Na, not sure it’s really a craze, at least not yet. But I figured I’d give it a go, gourd and bombilla style.

UPDATE:

I’ve now had some time to test the yerba mate and the gourd.

Learning how to properly prepare and drink the mate is certainly the first feat to overcome.  There are a number of good resources around the web.  I found this one to be particularly helpful.  When first preparing the mate, I found it useful to rinse the mate in the cup/gourd a couple times with cold water before pouring over with hot water.  This process allows you to get rid of any small dust/particles that are more likely to get pulled through the bombillia when drinking mate.

I’ve also started adding a few drops of stevia extract to each cup, prior to adding the hot water.  This helps to cut on the bitterness, but certainly isn’t necessary.

Overall, I’ve found yerba mate to have a mild stimulating effect that’s great for mind clarity.  It does seem to calm and even relax my muscles ever so slightly, which might not be for every situation, but is nice overall.  I’d certainly recommend adding yerba mate to your collection of tea products, and/or your lifestyle.  However, I’m not sure it’s a daily drinker for me, at least not now.  I’m going to continue drinking the mate and will update this again after more time has passed.

Until then, give it a go yourself and let me know what you think.

I have nothing more to say here, glad I could waste more of your time!

Secondly, I have this theory I cooked up one time while taking a shower, about how much more the brain can focus while showering due to temperature regulation and comfort.  My body isn’t having to expend additional energy to keep cool or stay warm, and it’s also not distracted by this unpleasantry.

I have a couple other reasons like the pleasant sound of the running water and the overall reliance of this as a thinking place.  So, this is why I take long showers, because it’s where I have some of my best thoughts.

Now, why am I sharing all of this with you and what does is have to do with “Where to Buy By-products?”.  Well, naturally I had an idea this morning that I felt needed sharing.

So, while taking my shower this morning, uninterrupted from the chaos of modern life, I began my routine standing under the water for a few minutes as my vision began to clear from my night’s rest.  After I began to see a bit more clearly, I reached for the facial scrub and proceeded to clean my face.  This isn’t just any facial scrub though.  This is an apricot facial scrub.  My girlfriend picked it out - I quite like it.  After scrubbing my face in hopes of ridding myself from any future breakouts, and sitting the scrub back down, I started to think.

Where does St. Ives get the apricot cores that are a key ingredient to their face scrub's success?  Do they buy fresh apricots just for their cores and remove the fruit's meat?  Maybe they send all their employees home with fresh apricots each day.  Surely not though, that'd be way too expensive.  Maybe they just buy rotten apricots from produce vendors, or maybe they have a relationship with various companies that sell canned apricots and have the seed core as waste - a by-product.  Yea, I bet that's what they do, that sounds the most logical.

So, if St. Ives gets their apricot cores from these relationships with apricot canning companies, how long did it take to establish those relationships?  I wonder if they have supply issues and quality control problems.  Finding other companies might not be that easy, and if you did find them, how's that conversation going to go?  "Oh hey, I'd like to buy your cores that you're throwing away".  I'm sure that conversation would be welcomed, but what about the logistics.  Does that canning company even know they have an opportunity available with their waste by-product?

Now, obviously these companies have some sort of way of obtaining these key ingredients today.  I don’t know what it is, I can only surmise for the time being.  But, I can only imagine that finding many of these ingredients is difficult at best.

Armed with this new revelation, I concluded that there is a need for a new marketplace where manufacturers can list up their by-products for sell and other’s in need of these by-products can arrange to purchase.  Not only would this provide a revenue opportunity for manufacturers with by-products seen and treated as waste, but it would also offer an easier way for others to find those key ingredients.  And also, it opens the door for a massive improvement in the re-use of waste, a key piece with regards to recycling.

All the tree-hugging hippies will rejoice and all will be good in the world.  It would be an excellent contribution to the world.

So, this is why I take long showers.  So I can have ideas like these every day.  So I can sort things out in my mind and take a deep breath from the constant stream of chaos.

Example…

You see, the problem with this is many fold.  I can’t read this b/c it’s out of order.  I scroll down, not up.  It’s mixed in with other tweets which make it even harder to follow as well.  But honestly, the thing that bothers me the most is that it’s basically spamming my feed.  If I want to read a blog article, I’ll do just that.  But if I’m not specifically interested in the topic at hand, don’t spam my feed with your opinions/thoughts.  It’s rude and not appreciated.

Now, the person that I used in this example is not the only person doing this.  There are many others, most of whom I choose to unfollow.  But this person I do respect and appreciate his comments, thoughts, and opinions, sincerely.  I just don’t want to have to read them in reverse and have a spammed feed.  So, this is my plea.  Please consider blogging on a blogging platform and linking to your thoughts.  A blog article doesn’t have to be long, short is okay.  Hell, Tumblr made that mainstream, right?

I have to say, Zendesk’s new homepage design and video background is pretty awesome.  It’s highly effective at speaking to their target market.  Well done, props!

Startups constantly struggle with client perception of the product.  The old adage and agile approach of “ship now” and “release; iterate often” is, in general, a good approach for startups.  However, it leaves many early customers with the perception that what they see of a product is what it will always be.  Most customers don’t understand how software  development and startups, in general, work.  Instead, they think when they try out a service, that’s what it is, forever and always.  In reality, that’s far from the truth.  Software is a living breathing beast that is always a work in progress, improving, pivoting, backtracking, growing, etc.

Therefore, I found this take-away message to be well fitting and deserved - kudos SaneBox.

Please try us again soon! Hopefully by then, we will be fit and tanned and ready for the relationship you always dreamed of!

Wordpress doesn’t come without it’s own issues.  I’m very well aware of them and they are pretty frustrating.  The codebase itself is a disaster, being written in php4, and a highly functional codebase.  I do prefer some OO goodness.  Nonetheless, I’m making the jump back.

I want better control over my urls, assets, features and functionality as well as customization.  Tumblr, naturally, didn’t offer much of this.  I do think Tumblr is a nice blogging platform for the average Joe.  I just don’t fit the category.  So, back on Wordpress for a while.

For those of you unfamiliar, the .xxx TLD was finally approved and released by ICANN a couple years ago.  It’s intention is/was to serve as a place for porn domains.  It make sense after all, right?  Porn, XXX, .xxx, why not?

Well, yes and no.  Sure, on the surface .xxx makes sense.  We’ll just get all the porn sites to register .xxx domains and in turn not index their .xxx websites in traditional SERPs.  Then businesses can blacklist the domains on their routers and more.  It’ll be a perfect utopia.  We’ll all move to Pleasantville!

The issue is pretty multi-faceted though.  Firstly, nothing on the internet, or in this world, is black and white (Pleasantville parallel).  Let’s take a few examples here that should be incredibly obvious to debunk this lunacy:

• If I’m running a porn studio, why would I want to register a .xxx domain that isn’t going to be indexed by the traditional SERPs and is banned by default by many content filters?
• Oh, there is this XXX movie.
• Many extreme sports companies brand along side the xxx theme, XXX Race Co, Moto XXX, XXX Motorsports, and many others.
• There are beer brands, Molson XXX and XXXX, an Aussie beer, to name a couple.
• How about some Triple XXX Root beer and a family restaurant!
• WrestleMania XXX, ZZ Top had an album, or how about some Vitamin Water XXX.
• Who knows, maybe you’re referring to the Triple X Syndrome, Amsterdam’s Coat of Arms, or Agent XXX of James Bond.
• it goes on…

The information varies and there doesn’t seem to be an authoritative source on the subject.  But it’s thought that it originated as a mark on beer casks.  According to Brewers on the subject:

"X on beer casks formerly indicated beer which had paid the old 10s duty, and hence came to mean beer of a given quality. Two or three crosses are mere trademarks intended to convey an impression of its extra strength."

Given all of this though, and the more loose coupling of the TLD with porn and legitimate companies and brands, it’s difficult to draw a clear and distinct line with the TLD and porn itself.  And, therefore, as a result, I never see this fully taking hold as a TLD to become synonymous with porn.  Furthermore, due to it’s easy remembrance, simplicity and personal appeal, I find the TLD extension an attractive asset.

I’m putting myself out there.  I’ve registered the .xxx domain for my family name and intend to use jacob@thomason.xxx as my personal email hence forth.  Or at least until ICANN launches affordable custom TLD registrations.

I should preface that there isn’t anything profoundly novel about this approach, and many might even find it a tad “nasty”, I did at first. It goes against what we’ve always thought was the right approach. But after we’ve refactored our js over and over, we’ve found ourselves constantly pushing towards the DOM and increasing cohesion. Keeping an open mind, I’m challenging that approach and freaking loving it so far!

So, what is this magical new approach that you’re sure to scoff at on first glance, but if you keep an open mind, will hopefully see the value? Well, it has to do with decoupling and cohesion. There is an awesome talk put on byPete Hunt, a Facebook engineer and core team member of the React Project, on the subject. I suggest watching this video. A friend actually pointed me to this video when I was explaining this new methodology at which I’d arrived. Clearly I was not the only one on this wavelength. And while it’s a requirement for React’s virtual DOM, I’m suggesting the event binding implementation in a more mainstream sense.

With that all said, let’s dig into specifically what I’m talking about here and discuss a few positive and negatives, etc.

Firstly, what’s the problem we’re solving… Event binding sucks. It’s a real pain. Not only is it annoying to write the first time, it’s even harder to keep straight all of your bindings as an application’s UI morphs. That’s not even mentioning all the bugs that can arise from incorrect selectors, etc. Let’s take an example:

$(“a.add-new”).on(“click”, function(event) {    //do stuff});

Now, let’s take a look at what we did here, super simple, but I want to point out something. This is just a simple event binding on the node itself. But, note that the selector specifies the element. This is something I’ve long been a fan of doing out of practice. It’s not the fastest selector, but when refactoring and reading code, it tells you something more about the selector and the resulting code. Here is a further example:

$(“body”).on(“click”, “ul#users > li a.add-new”, function(event) {    //do stuff});

In this example, we took the previous and did a couple more things. For one, we delegated the binging to the <body> and expanded the selector to be more clear exactly what it is. Now, again, not fast, no. But, I can see that clearly, it’s an anchor for adding a new user. This is good for a couple reasons. One, as I mentioned, the ability to clearly see the chain and what’s happening. And two, using longer selectors like this allows you to prevent collision among selectors and allows you to keep the DOM clean. You don’t have to have selectors like a.-add-new-users-button-under-left-column-when-enabled. Any time I see a selector like this I cringe ><.

So, what does all this selector jazz have to do with cohesion and the collective DOM, you’re probably asking… Well, it has everything to do with it. The only reason we spent all this time making sure our selector chain was easy to read and follow within our JS is so that we can read the code and know what’s happening more clearly. Sometimes the javascript code itself isn’t enough to fully know. In these cases, you need more contextual clues. Comments do help, but sometimes they can get out of control as well.

Taking a step back from this and thinking more on it, we’re just trying to create more cohesion between our JS and our markup/DOM. Now, this isn’t intentional as much as it’s really a necessity for continual refactoring down the road. When I started giving this more and more thought, I began to ask myself, why we’re even attempting this decoupling in such a way. And this is where I came upon the following approach:

<a onclick="//dostuff" class="add-new">Add New User</a>

So, yea, inline event handlers! You saw that correctly, yes…

This isn’t it though, there is more, but this is the concept. Allow me to expand on it first. Before we had one page ajax web apps, we had standard anchors with uri’s (still can too if you want to watch for url changes), but honestly, most apps don’t and don’t need to. Graceful degredation, a primary benefit, is generally considered unnecessary work since nearly every browser used today supports javascript — a requirement to use most of the internet. So that said, my take on this is nothing more than a progression of the href attr. Work with me here… Where we use to have href=”/path/to/new/page.html”, in most new apps, you no longer need traditional paths. Instead your buttons and anchors are calling functions, which are making ajax requests and pulling in new json for parsing or doing various other functions required by your app. And because of this, I look at the inline event handlers as a progression.

Disclaimer: I’m well aware of what people say and that these handlers were a thing of the 90’s. I don’t care.

So, let’s take this a couple steps further to complete this approach.

First, I should probably talk a bit more about the organization of js code within an application. This is a topic in and of itself, but in short, I highly recommend setting up “Models”, if you will. Take for example the following:

var Model = Model || {};Model.User = Model.User || {};//yes, I like underscore.js_.extend(Model.User, {    add: function() {        //do stuff    }};

This is just a simple example, but hopefully you get the idea. Think of it a bit like PHP’s PSR-0 for js ☺

The benefits of this approach are pretty far reaching and this is deserving of an article in and of itself, but a requirement for the proper implementation of the suggested approach. So taking that with us, we now have something like this:

<a onclick="Model.User.add()">Add New User</a>

Now, I don’t know about you, but to me, this is pretty awesome. It’s clean and direct, nothing else in the way. I can also pass in arguments as needed which are almost always available within the DOM for actions like “remove”, “edit”, etc.

This is also not only limited to onclick, onsubmit is another great one, but you could use any event handler needed. For something with custom/unusual handlers I’d probably still resort to registering them within the js files.

So, the benefits:

• No longer the need to store as many data attr’s for ids and other variables that need to be passed to a function when the event is fired. These are simply added to the function call as arguments.
• Delegation is no longer a requirement, dynamically added DOM nodes would simply have their event handlers included when inserted.
• You can keep your js code much cleaner without the need for a large portion of event hander registrations.
• Garbage collection with delegation for dynamically added nodes isn’t a concern since when the node is removed from the DOM, the event handler is as well.
• No longer do you have to search around when debugging an UI for what is “firing” on a handler. It will be plain as day and you will know where to go to edit/view the code.
• You are forced to keep it DRY!

• If you have thousands of DOM nodes on a given page with associated event handlers, it could be taxing for the browser. I haven’t tested this, so I can’t confirm. I do consider this to be a much more rare scenario and more of a performance enhancement than anything else. But it’s worth mentioning. You can always just delegate in this case, no big deal.
• You’re putting your logic in the global scope with the “Model” approach. However, this can be a benefit as much as a negative. It’s nice to be able to call an “action” from anywhere it’s needed without having to build the prototype.

I’m certain I’m not the first to take this approach, it’s nothing super novel. But it’s been the result of years of refactoring and improvements that have led me to this conclusion. There was always an aching to get closer and closer to the DOM with the js. Your markup and your js will always be tightly coupled, there isn’t any way around it and the separation of concerns simply isn’t currently feasible. For this reason, I prefer to accept it instead of fight it, and I’m loving it!

P.S. — I’m aware of the many new frameworks that address these concerns and others. However, when refactoring, implementing a framework doesnt’ always make sense. Also, this approach is very simple and achieves a very nice result in itself, without the need to be dependent on a framework.

I’ll tell you why I’m livid.  It’s not because the site is experiencing load levels that their infrastructure can’t handle. It’s not b/c this chat window is hard to read and that the chat agent gives me canned replies and blames it on traffic levels.  No, it’s none of that actually.  In fact, I can deal with that, I develop software and actually understand how some of the scaleability issues may have been underestimated and difficult to address at such short notice.  Nope, that’s not it.

It’s the fact that the basic login system is the worst I’ve ever used.  Well, maybe not the worst, but certainly the worst I can recall in recent memory.  That’s saying a lot too.  I’ve used a lot of sites!  So, you’re probably wondering.. Well Jacob, what makes it so bad?  Glad you asked!

Firstly, in order to create a username, this is what’s required…

The username is case sensitive. Choose a username that is 6-74 characters long and must contain a lowercase or capital letter, a number, or one of these symbols _.@/-

Wait, what?!  A case-sensitive username?  Really?  Oh, I get it… we’re being more secure!  Genius!  Now, no one will remember their username, perfect!

Next up, passwords.  Now, this actually isn’t a huge concern, I’m all for forcing some requirements in passwords used.  This is mainly b/c users, for the most part, are rather stupid, and will use some really bad passwords if you allow them.  And, I’m sure, on a site like healthcare.gov, some really really bad ones.  But, what really got me about the passwords, was it’s description…

Your password must contain 8-20 characters. There must be at least 1 upper case letter, 1 lower case letter, and 1 number. It must be different from your last 6 passwords. It can’t contain your username or any of these characters = ?<> ( ) ‘ ” / &

What, what?!  My last 6 passwords?  How do you know what my last 6 passwords were?  Is this suppose to be some sort of security feature?  Sure, I realize that PCI-DSS compliance requires passwords be changed every 90 days.  I’m not really sure that level of security is needed here, I certainly don’t want it or care for it.  But, let’s just assume it is needed.  Why are you storing my last 6(+) passwords?  I’m assuming it’s b/c you want to ensure that it’s changed and isn’t accessible for a longer period of time.  That’s all well and good, but you now have a database of extensive passwords on hand.  That doesn’t make me feel good!

So, anyway, after you’re able to actually create some credentials that will get you through the account creation process.  You’ll get an email confirmation.  No problem, click the link, account verified, then wait ~90 seconds… for something… (database replication?) before you’re able to login.  Great, whatever, I can deal with that.

Whew!  I’m now at the login page, finally.  So, I plug in my login credentials and click to login.  Failed..  That sucks, maybe I already forgot my login credentials.  After all, that username is certainly not one I’ve ever used before, or again for that matter!  Maybe I’ll request that I’ve “Forgot my Username”.  Giving that a try, it’s unable to locate my “Marketplace Profile”.  Great!  

How about “Forgot my Password”, maybe that’ll do it.  So, I punch in my details and success, I get an email with a link to reset my password.  I’m now one step closer to affordable health insurance!  Or so I thought… The link takes me to a page where it’s unable to locate my “Marketplace Profile”.  Now, how is it that you’re unable to locate my profile, but you could locate it to send me a password reset link?  How does that work exactly?

So, here I am, unable to login to healthcare.gov in order to get my affordable health insurance I was promised, typing up a post, livid that our gov’t can waste money handing out contracts to people that clearly shouldn’t be developing applications of this scale.  I think what bothers me the most, is the fact that I know this contract was handed to someone who’s a friend of a friend of a supporter…

Giving it another go, maybe they’re db is sharded off to unavailable or delayed replication nodes, who knows.  I type in my credentials once again.  After all, Mariana on livechat said to try later, they’re having issues with traffic.  So, I plug away for the umpteenth time, and… success!  It looks like it’s going through…

Ya know what… f’it!

Why not have a universally accepted localhost TLD though?  It seems pretty logical to me and there could certainly be many purposes to having something like this.  ICANN is already in the process of deploying new gTLD’s in an effort to make more loot, where companies are already contracting for their own gTLD’s.  I fully expect that these gTLD’s will turn into service wrappers, so why not have something for localhost?

So, I guess maybe you’re wondering what the solution is to this to at least get it working?  The good news is, it’s super easy!  Just add http(s):// before the domain to train Chrome not to perform a search and instead use the protocol.  It’s an easy solution, maybe not obvious in a day where we rarely see or use the protocol with the url, and increasing less so as we move into an age of crazy gTLDs.

As an example, let’s talk about a simple example class for a module with options that can be set.  Many times you’d see this written one of two ways for the options.

The first example is probably the most common and simplest. We just use simple public methods that take a string and return the result. The advantage of this is that it’s clean and simple. There are many downside, but primarily, you don’t know if the string you passed is correct or not and you don’t have any autocomplete.

<?php
namespace WidgetFactoryModules;
class MyModule extends MyORM
{

    /**
     * Shared method to get the option value from the db
     * @param string $option
     * @return mixed
     /
    public function getOption($option) {
        return $this->query(“SELECT value FROM module_option WHERE name = ?”, array($option));
    }


    /*
     * Update the option value
     * @param string $option
     * @param mixed $value
     * @return mixed
     */
    public function setOption($option, $value) {
        return $this->query(“UPDATE module_option SET value = ? WHERE name = ?”, array($value, $option));
    }
}
        
    

Adding onto the last example you’ll notice that custom method names were added for each option passing the string param to the shared getter and setter methods. The advantages of this approach is that you don’t have to worry about mistyping strings with passing them as parameters and you’ll get to maintain autocomplete, allowing you to see all the options available. Not too bad, but a little cluttered in my opinion and harder to maintain.

        <?php
namespace WidgetFactoryModules;
class MyModule extends MyORM
{

    /**
     * Shared method to get the option value from the db
     * @param string $option
     * @return mixed
     /
    private function getOption($option) {
        return $this->query(“SELECT value FROM module_option WHERE name = ?”, array($option));
    }


    /*
     * Update the option value
     * @param string $option
     * @param mixed $value
     * @return mixed
     /
    private function setOption($option, $value) {
        return $this->query(“UPDATE module_option SET value = ? WHERE name = ?”, array($value, $option));
    }


    /*
     * Should we send emails with this module?
     * @return mixed
     /
    public function getOptionSendEmails() {
        return $this->getOption(“sendEmails”);
    }


    /*
     * Update the sendEmails option
     * @param mixed $value
     * @return mixed
     /
    public function setOptionSendEmails($value) {
        return $this->setOption(“sendEmails”);
    }


    /*
     * Is sharing to social networks enabled by default?
     * @return mixed
     /
    public function getOptionShareByDefault() {
        return $this->getOption(“shareByDefault”);
    }


    /*
     * Update the shareByDefault option
     * @param mixed $value
     * @return mixed
     */
    public function setOptionShareByDefault($value) {
         return $this->setOption(“shareByDefault”);
    }
}
        
    

After giving this some more thought though, I was thinking about the power of constants to improve on this and came up with a bit of a hybrid, if you will.

        <?php
namespace WidgetFactoryModules;
class MyModule extends MyORM
{
const SEND_EMAILS = "sendEmails";const SHARE_BY_DEFAULT = "shareByDefault";/** * Shared method to get the option value from the db * @param string $option * @return mixed */public function getOption($option) {    return $this-&gt;query("SELECT `value` FROM `module_option` WHERE `name` = ?", array($option));}/** * Update the option value * @param string $option * @param mixed $value * @return mixed */public function setOption($option, $value) {    return $this-&gt;query("UPDATE `module_option` SET `value` = ? WHERE `name` = ?", array($value, $option));}
}
        
    

Something along these lines. This is obviously called with something like…

        $myModule = new WidgetFactoryModulesMyModule;echo $myModule->getOption($myModule::SEND_EMAILS); //sendEmails            

Now, this is certainly not complete, you could put some checks in place within the class to ensure you’re getting a valid value, then throw an exception. You could also make the getOption method static and setup a constructor if necessary to instantiate the class. But overall, I quite like the idea. You’re able to keep a clean class, easy to maintain, and you still get autocomplete.

I’d love to hear other people’s thoughts on this topic. Let me know!