IE10 And jQuery Browser Version Checking

Mar16
2013 Leave a Comment Written by JBlake

In the latter months of 2012, Microsoft released Internet Explorer version 10 for Windows 8. It was not available for Windows 7 or below at that point. It wasn’t until the end of February 2013 that IE10 was available for Windows 7. Now that it is out, it’s starting to reveal some issues with some of the ways that things may have been done in the past.

The major issue I’ve seen so far is that with IE version checking. It has always been a solid recommendation to base browser version information on testing of features, but in some cases, that simply isn’t practical. Specifically, one of my clients had some work that involved packaging their own fully contained javascript sdk. In such an environment, it has long seemed like a reasonable and safe fallback to rely on jQuery’s $.browser information. This call was deprecated quite a while back, but it has continued to be supported. That’s still true, but it became less true when jQuery released version 1.9 in mid January 2013, as that release is coming with an announcement that $.browser has been removed. That’s not the issue at hand in this post, but is worth noting, if you happen to be reading this and are looking for a way to fix your jQuery’s issues with detecting IE10.

Returning to the issue at hand, when IE 10 came out, some of the standard mechanisms for checking IE versions with $.browser suddenly ceased to work right (and this was the case for my client as well, which is why I know about it to begin with). The issue stems from the fact that $.browser stores the version number as a string. That sounds strange, but there is good reason for it. You see, a version number for most forms of modern software isn’t just something like IE version 10. Rather, it will end up looking much more like IE version 10.0.3.1.38.257. This allows the developers to expressly know exactly what build version is in use, to fine-tune new features and bug fixes. And since a number can only have one decimal, this has to be respresented as a string.

Thus the standard way to compare to a known major version is going to be comparing strings. Something along the lines of

if ($.browser.version < "7.0") //perform actions for old browsers...

That worked for a long time. But we now face an issue. You see, 10.0 is greater than 7.0, if you are comparing numbers. However when comparing strings, different rules apply. "10.0" is less than "7.0", in the same way that "Azxz" is less than "Bxz". Thankfully, there is a simple solution: convert the version back to a number, and then compare it to a numeric value. Since it is a safe bet that we won't have to worry about software versions in the thousands (for the major release number), we can look at the first three characters. That is important, since more than three characters would open us up to the possibility of having multiple decimals in the string, such as "8.1.xxx". Three characters gives us "8.1", which will convert to 8.1 (however four characters would give us "8.1." which would not execute properly).

The final code then for solving this problem is to adjust our earlier check to incorporate this process. So it becomes something along the lines of

if (parseInt($.browser.version.substring(0,3)) < 7.0) //perform actions for old browsers...

The one caution I want to stress about this is that it will absolutely fail if/when the related pages are updated to use jQuery version 1.9 or newer. But if you are operating on an older-than-the-latest-version, this could give you a quick fix for a rather troublesome problem. Enjoy!

Posted in $.browser, best practices, javascript, jQuery, numbers, strings, types

neXrm: My New Gig

Mar16
2013 Leave a Comment Written by JBlake

I’m starting to have a trend of making posts and then disappearing. Unfortunately, I’m not really enough of a blogging celebrity to pull that off the way that folks like Jeff Atwood are able. That said, chances are fairly good that it’s not going to change too much in the near future, because…

About a month ago, I got a new job as a software development contractor for neXrm. The good components of the job are that I’m continuing to grow my .Net experience, and that it pays pretty well and has good benefits for the things that their benefits package covers. The bad things are that there is no retirement component to that benefits package, and that the current assignment has me commuting about 120 miles per day. We’ll see how things pan out in the long run. It’s definitely a good step for now, at the very least.

My wife and I are still going to be running Grinderschool Poker Training on the side, and I will continue limited work with IWI if/when client requests come in. It’s actually kind of interesting that one of the things which have come out of the long commute is time to listen to the huge backlog I have of StackExchange podcasts. That has led to a lot of ideas about things I can do to improve Grinderschool, when I can find the time to do so. Expect to (eventually) hear more about that down the road.

Posted in .Net, Grinderschool, IWI, neXrm

Building My Windows 8 Fileserver

Dec16
2012 Leave a Comment Written by JBlake

In my post about relaunching Interware Innovations, I noted that I was building a fileserver to support IWI operations. There are four goals that this machine was to fulfill.

Shared File Storage: The primary purpose of the fileserver is to act as a single point of storage for files used to produce and backup the poker strategy videos of Grinderschool.com
Database Backup: The secondary purpose is to maintain backups of the various data stored in the Grinderschool data
Source Control: The third purpose is to act as a source control server/repository.
Web Server: An auxiliary use is to function as a web server, supporting any development projects that need a non-local server to provide a realistic test environment.
Development Database Server: Another auxiliary use is to serve as a database server for projects under development.

In this post, I will discuss setting up the machine and getting it to the point that it fulfilled my primary goal.

Going into the project, I had some resources available, but had a few things that I still needed to acquire. I had: two large hard drives for storage, a chassis, a motherboard with on-board LAN, CPU, and RAM. I still needed: a small hard drive for the OS, a video card, an OS, and any required software.

One of my friends runs a computer repair business called Computer Trendz. This came in handy as he was able to provide me with the hardware at an incredible price, and he had a copy of Windows XP that I could use temporarily to prep for setting up Windows 8 as my OS (meaning that I could go with the $39.99 upgrade). The upgrade version worked smoothly and did not even require the license key for XP, however there was one small hiccup here. XP was a 32-bit OS, and the hardware in my server would support 64-bit operations, however Microsoft’s upgrade utility would only load the same architecture that was running on the current OS. That meant that my initial attempt installed the 32-bit version of Windows 8. After a bit of digging around online, I found a solution. Since my workstation is running Windows 7 64-bit, I was able to use my key for the upgrade to download the 64-bit version of Windows 8 as an ISO. Then I burned it to DVD and successfully used that DVD to install Windows 8 64-bit.

Next came configuring file sharing, in order to support the file storage goal. Windows 8 offers the use of Home Groups to do sharing, however, I preferred to go with drives shared through the typical sharing options available as properties when you right-click on any file or folder in Windows. I made this choice because all work stations that will connect to the machine are easily able to have network drives mapped (which fits much better with the existing structure we have established for producing Grinderschool videos). I used per-user permissions for the file sharing, but this led to a strange issue in that the root of each drive would only allow users to create folders and read existing files. No write permissions were supported. To solve this, I had to add the authenticated users group to the permissions settings for the drives in question, providing full control for each. With that done, the initial setup was complete.

In part two, I will continue with details and links to the solutions I embraced for configuring the file server to fulfill the remaining goals.

Posted in business stuff, Grinderschool, IWI, Server config, system administration, Uncategorized

Relaunching Interware Innovations

Nov26
2012 1 Comment Written by JBlake

A lot of things have changed in the last couple weeks. The biggest change is that I am no longer part of Rubicite Interactive. It is an fairly amicable split – the other partners and I decided to move in different directions. The distribution of my equity was pretty fair as well, coming in three parts: finances, computers/parts, and project assets. I am using these to renew operations with the company I formed in 2001: Interware Innovations (IWI).

The focus at IWI is going to be similar to where I focused while at Rubicite: Software development of any kind for my clients will get top priority. I expect the major component of that to continue to be in web applications driven by ASP.net or PHP, with javascript and HTML5 supporting the front-end and MS SQL or MySQL providing database support on the backend. Naturally, I will be happy to shift that focus in whatever way works best for my clients – I have plenty of experience building programs in C#, Java, or VB. And an interesting opportunity is on the horizon in one client potentially seeking an iOS game which I will happily delve into should all the pieces line up. A few of the clients I supported at Rubicite are sticking with me through the move to IWI, and naturally my absolute top priority is on continuing to provide top-notch service to them.

As client needs allow, getting IWI fully operational is the next priority. Aside from client work, all IWI projects are on the back-burner until everything is running smoothly in our new office. The finances I received in the split will be enough to ease through the transition. The project assets amount to me regaining full ownership of Grinderschool.com – the site I launched in 2007 focused on<a href=”http://www.grinderschool.com” target=”_blank”>poker training videos</a>. That will provide some income and keep me busy in any downtime I have between client projects. Finally, the computers amount to a beefy workstation, peripherals, a monitor, and a set of parts (case, power supply, motherboard, processor, and ram) which I am using to build a fileserver. That process is mostly complete. It took longer than I had hoped, but I am happy with where it ended up. Expect another blog post in the near future wherein I will detail the steps that went into building that machine and getting everything setup.

Once all of that is done, when there are breaks in work for clients, I will delve into a set of IWI projects. The first two items on that list are getting an IWI site online, and upgrading various parts of Grinderschool to make things run more smoothly and to increase the value we provide to our subscribers.

Posted in .Net, business stuff, Grinderschool, IWI, PHP, Rubicite, SQL

Linq Ignores Default DB Values?!??

Jul31
2012 Leave a Comment Written by JBlake

After some recent updates to our latest web-app, I found that certain situations were resulting in an error when inserting to the database. Specifically, situations where non-nullable columns did not have a value assigned in the web-app. Now, before you get excited, in this case, I had done my due diligence as a database designer: the columns in question had default values specified in the database.

The problem, quite simply, was that they were being ignored by Linq. After doing some digging around, I found that this is a problem that prompts many complaints. And well it should prompt many complaints. Setting default values in the specification of a database table is a feature that virtually every modern DBMS supports. How dare Linq screw around with this feature!

There were a few suggestions on how to fix this issue listed on StackOverflow, but they did not solve my problem. I ended up following the pattern laid out in Stefan Sedich’s blog and going into the code for the Linq object to add a partial OnCreated() function to the partial class controlling the field I was dealing with – for the sole purpose of checking the field for a null value and setting it accordingly.

This works. But it has me outraged. How dare Linq violate such a basic tenet of database interaction as the default value!!!

Posted in databases, LINQ, SQL

Stirrings of an RTS Game

Jul12
2012 Leave a Comment Written by JBlake

Note: This entry was cross-posted to both http://coding.jgb146.com and http://gbwg.jgb146.com

The main goal at Rubicite is for us to keep moving in a financially sound direction as a software development company. For the foreseeable future, that means focusing a large majority of our efforts on development for paying clients. However, at our core, we want to be a game development company. To that end, one of our partners spends the majority of their time pushing forward on our first game – a third-person shooter in which an advanced race of snails battles against several enemies. You’ll definitely hear more on that as it moves forward – eventually we will be posting it on Kickstarter to get sufficient funding to commit more resources. But that’s not what I’m here to talk about today…

The snail game is our first game. With any luck, it will see a 2013 release. As exciting as it is, I’m much more excited for our second game. By all counts, it will probably be a 2015 release, but plenty of things could happen to move that forward or backward between now and then. Currently, it’s in the early concept stages, and it’s becoming my baby. For now, the codename behind this project is Giant Bloody War Game (GBWB), as a nod to Bungie for the codename used when developing Myth. Here’s a bit about what we know:

The gameplay style will be modeled after Myth and Myth2 (no, not Myst): a couple of games developed by Bungie in the late 90′s (prior to that whole Halo thing). That means it will be a real-time strategy game with viritually no resource-management, where the driver for the gameplay is using combat tactics with a relatively small number of units and a realistic physics engine. This means that the terrain you choose for your battles will matter. Having a height advantage will impact the performance of your ranged units. Formations and micro-management will turn the tide of battle between two otherwise equal forces.

Currently, we are quite a ways from implementing any of that. Like I said, early concept stages. What I’m slowly developing now is the backstory for the game. Which is both driven by the unit classes I envision, and drives me to create new classes to fit the story. Both, in turn, will drive the level design that will be central to many elements of the gameplay.

The story is centered around a post-apocalyptic Earth. I haven’t decided for sure what caused the apocalypse, but I’m leaning heavily toward a series of comet/asteroid collisions. In the time between the apocalypse event and when the game starts, months (or years) have passed. A shortage of resources has led to civilization breaking down, with many small groups forming and warring with each other. Many have died since, but some groups are pushing for a brighter future. Much of the world’s ammo and weaponry were rendered useless during the destruction from the apoc event. The majority of what is left has been exhausted from the wars. Meaning that where war is concerned, humanity has largely returned to a time of modern versions of medieval weapons. Guns and other more modern weaponry still exist, but ammo is in such short supply that they are rare.

Oh, and there are some non-human creatures (not in the way you’re thinking) with unique anatomy that will have meaningful impact to both story and gameplay.

The major story element I’m currently struggling with is how to explain a way that these creatures can communicate with humans.

Once it’s all said and done, I expect to end up with a novel that mirrors the story of the game. I look forward to releasing it, almost as much as I look forward to the game itself.

Posted in game development, gameplay, GBWG, Rubicite, storyline

Paypal IPN and PDT in ASP.net

Jun07
2012 Leave a Comment Written by JBlake

To support a customer who needs to process payments through Paypal, I created a small code package that encapsulates the functionality necessary for the operations used in Paypal’s Payment Data Transfer (PDT) and Instant Payment Notification (IPN). This way, the code is reusable for future projects within Rubicite. I’m sharing it on Github, so that it can save some time for the rest of the world: https://github.com/jgb146/Paypal-util

Most of the functionality involved is derived from various tutorials in Paypal’s documentation, but this way everything is encapsulated into a single pdt_hander object, or a single ipn_handler object (depending on which technology you’re using). The resulting object automatically takes the steps required for confirming the contents with Paypal, and then provides you with access to your payment information through a Dictionary.

To use either component, simply instantiate the object and provide the required information. For PDT, that means including the transaction ID that Paypal sent, your PDT ID token, and an optional boolean to indicate whether or not you are using Paypal’s sandbox. For IPN, the only parameter to include is an optional boolean to indicate whether or not you are using Paypal’s sandbox. Use looks roughly like this:

IPN:

protected void Page_Load(object sender, EventArgs e)
{
    processIpnPost();
            
    Response.Clear();
    Response.StatusCode = 200;
    Response.Write("");
    Context.ApplicationInstance.CompleteRequest();
}

public void processIpnPost()
{//process the IPN post
    
    //use ipn_handler util to get response and load into a dictionary
    PayPalUtil.ipn_handler ipn_handler = new PayPalUtil.ipn_handler();
    Dictionary dic_ipnResponse = ipn_handler.dic_data;
    
    //deal with invalid responses
    if (dic_ipnResponse["response"] != "VERIFIED")
        return;

    //---Insert code to use dic_ipnResponse to process the transaction
}

PDT:

protected void Page_Load(object sender, EventArgs e)
{
    ProcessTransaction();
}

protected void ProcessTransaction()
{
    //deal with unspecified transactions
    if ((Request["tx"] == null) || (Request["tx"] == ""))
    { 
        InvalidTransaction();
        return; //stop processing; 
    }
                
    //use the transactionID in the GET to request & process PDT data
    my_pdt_handler = new PayPalUtil.pdt_handler(Request["tx"], PDT_ID_Token);

    //deal with invalid responses
    if (my_pdt_handler.dic_data["response"] != "VERIFIED")
    { 
        InvalidTransaction(Request["tx"], my_pdt_handler.dic_data);
        return; //stop processing; 
    }

    //---Insert code to use my_pdt_handler.dic_data to process the transaction           
}

protected void InvalidTransaction(String pStr_transactionID = "", Dictionary pDic_data = null)
{//invalid transaction -> handle however you feel is best

}

Posted in .Net, ASP, IPN, Paypal, PDT, Rubicite

New Directions & New Digs

Jun05
2012 Leave a Comment Written by JBlake

Things at Rubicite have been a bit tumultuous of late. One of our partners (we’ll call him X) decided to leave the company. X and our CEO are brothers, and family drama entered into work on more than one occasion – something for which they were both at fault. In the end, X chose to leave because the stressful conditions that this created weren’t worth it in his eyes. All parties were happy and pleasant about the break; we took X out to lunch at his favorite restaurant (a tradition I enjoyed at NSA, and one I intend to continue here with Rubicite).

A few things will be happening as a result of this. First, Rubicite is buying X’s shares. That’s creating some difficulty because X held around 35% of the company and a large chunk of our financial assets are in a set of invoices that haven’t yet been paid. In the end, he’s going to have to wait a few weeks for the final payout. And we’re going to be strapped for cash for a few weeks until some invoices get paid.

Second, the remaining partners all have more ownership of Rubicite now. X’s shares are being split proportionally to our previous distribution, which takes me from 15% to around 23%.

Third, I get X’s office. That was going to happen anyway, since X worked from home a lot. But the timing worked out pretty well, since I just got my new desk delivered and it was going to make my old office pretty crammed. The new office is bigger than my old one (around 14 x 11 instead of 11 x 10), and it has two windows. In the new office, the desk fits comfortably, with room for a nice seating area should I need it.

Fourth, Rubicite’s finances should improve more quickly. For at least the last six months, X has been working on internal projects that did not make us money right now. Among other things, those projects included coding for our first computer game, and improvements to Grinderschool. Both were valued contributions, but having a large portion of our work-force not on paying work led to slower growth than we might have seen otherwise. Instead, we will now see slower improvements to Grinderschool and the game will likely take a bit longer to get to the point of seeking funding, BUT we should be making money significantly more quickly than we are spending it – meaning salary increases should be a bit less distant on the horizon.

Finally, the rest of us will have to adjust our work in order to keep moving forward on the projects X was working on. We want to do so in a way that will lead to minimal drain on our billable time. That will probably mean some extra hours for each of us here and there, and it will also probably mean that X’s projects slow down a bit. I’m becoming a bit excited at the prospect of getting my hands into the mix for our first game – previously I had envisioned myself as being more-or-less only in the web development side of Rubicite.

We are having a company meeting later this week to look at finances and develop the future work-plan for Rubicite. More will certainly be decided then.

Posted in Grinderschool, Rubicite

Serving Unlimited Domains From IIS, pt 2

May21
2012 Leave a Comment Written by JBlake

Last time, I posed the question of how to serve unlimited domains from IIS. I got to digging around, found some options myself, and had some better options revealed to me by folks in the Tulsa WebDevs Facebook group and by my partners here at work. So here are the options, as I currently understand them:

1) Build It Into The Code
Probably the best option is to programmatically create bindings in IIS6 and/or in IIS7. This way everything is integrated into the webapp, meaning there’s no muss or fuss outside of the app. It requires a bit more work in the app itself, but the benefits of keeping things clean and keeping all the functionality around this action inside the single codebase are almost definitely worth it.

2) PowerShell
Another option is to set up a script for powershell to have it handle this stuff based on the script detecting changes to the database. This would work well also, but has the drawback of creating two codebases to maintain.

3) Remove Domain Bindings
This StackOverflow answer led me to try removing the existing domain from the webapp’s bindings in IIS. Making this change resulted in being able to reach my webapp by just visiting the IP address (so the binding was no longer an issue). And the one domain we have set for this webapp so far still reached the desired site as well. So it seems that the solution could be as simple as to have no host/domain listed in the bindings on IIS. As long as only one site does this, all traffic that does not match another binding loads that site. A big upside here is that it takes less time/effort than any of the coding solutions mentioned above. The downside is that you can only have one site on the server perform this way, and you can no longer have the server locked to only serving content with recognized domains.

Posted in ASP, IIS, powershell

Serving Unlimited Domains From IIS, pt 1

May18
2012 2 Comments Written by JBlake

In an upcoming version of a currently-in-development webapp, I need to serve multiple domains from a single site. The code on the site will recognize the individual domains and vary the content accordingly. I do not know all of the domains that we will be serving, as clients can add new domains to their site. The coding parts, I know how to do – when clients add a domain, there will be a corresponding entry into our database and that will act as a key to control which set of content is shown.

The thing is, I suck at system administration. If I knew the domains ahead of time, I could simply point them to our server’s IP and then create bindings in IIS to handle each. But since I do not know the domains ahead of time, I’m rather at a loss. I welcome any suggestions. Expect part 2 of this entry in the coming weeks, to reflect whatever solution I find.

Posted in IIS