If an exception is thrown in a BackgroundWorker’s DoWork handler, the backgroundworker will catch it and place the exception in RunWorkerCompleted’s e.Error.

If it seems like the Exception’s still being thrown with no apparent way to catch it, it’s because if e.Error is not null. When that’s the case, e.Result will throw that error (wrapped in a TargetInvocationException) when accessed. Do not access e.Result without checking for e.Error first.

private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
  EndCreate(e.Error, e.Result); // <--- THIS WILL CRASH IF e.Error IS NOT NULL
}
 
private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
  // THIS WILL NOT.
  if (e.Error == null) {
    EndCreate(e.Error, e.Result);
  }
  else {
    EndCreate(e.Error, null); // accessing e.Result throws the exception
  }
}

That said…

Most code editors have figured out this whole code folding thing where you click on the minus button next to the function block and it collapses into a neat declaration.

Zend Studio has this too, only with a slight twist. Most of the times it works right. Other times, it forgets to fold bits. Yet other times, especially when folding PHPDoc blocks, the fold swallows whole unrelated fields/functions that happen to be next to the one I want to fold, declaration and everything. Nice.

I could understand this slipping past testing given how intermittent it is, but ZS’s been around for at least a couple of years, and it’s got like a dozen version updates, one of which explicitly touted having better folding. Yeah, it’s better, because before it screwed up half the time rather than a 10th of the time. It still sucks.

And while on the subject of sucking, in what universe is it sensible that if I edit a file that exists in a ZS project outside of the environment, and then try to open it in ZS, it flips out in glorious fashion:

And then I right click on the offending file, click on Refresh, and it’s happy again. If it knows it’s out of sync, why the hell can’t it refresh it automatically? The file’s right there!

Makes me want to hit it. Surely I can’t be the only one running into this stuff?

You see, I’m thrilled at the knowledge that some piece of the software I use every day received an update and got a little bit better. Maybe a potential security problem was solved, maybe some performance was added, or maybe some kink was ironed out. Whatever it was, I love the feeling that something that was making my life an insignificant bit harder is going to go away in the new release. Even if it didn’t affect me before, the knowledge that it’s not ever going to gives me a little bit of peace of mind.

But, you know, I have to know about it. If I don’t, I can’t feel good about it.

And it’s especially mean of you to have a large “What’s new” button that just takes me to your homepage. Then you’re just being a cocktease.

1. Set the DefaultValue property on the respective DataColumns.

   This works fine for static values. However, you’re likely using the DataSet designer in Visual Studio, and it will hose itself if you try to set a GUID because it can’t tell them apart from a string. Plus, initializing with dynamic values like DateTime.Now won’t work because you’ll end up with the date of the creation of the column rather than the date of the row.

2. Initialize after creating it, but before adding it to the DataTable.

   If you’re creating the row manually, you can just set any initial values before adding it to the table. None of the values, indices, etc. are validated until that happens. Strong typed datasets are even nice enough to generate methods that take and return rows of your type.

   MyDataSet ds = new MyDataSet();
   MyTableRow row = ds.MyTable.NewMyTableRow();
   row.ID = new Guid();
   row.CreatedOn = DateTime.Now;
   ds.MyTable.AddMyTableRow(row);

3. Override the OnTableNewRow of the DataTable in a derived class. This doesn’t actually work.

   Like the derived classes created by the strong typed table generator. You can get to this method if you use the DataSet’s helpful partial class definition:

   // Note: does not actually work
   public partial class MyDataSet {
       public partial class MyTable {
           protected override void OnTableNewRow(DataTableNewRowEventArgs e) {
               MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)e.Row;
               row.ID = new Guid();
               row.CreatedOn = DateTime.Now;
               base.OnTableNewRow(e);
           }
       }
   }

   It doesn’t work because this method is never called unless you also attach a handler to the TableNewRow event, defeating the whole point of creating a virtual method. GG, Microsoft. This set me back a whole afternoon trying to figure out why some of my tables ran the method and others didn’t.

   You can overcome this if you…

3. Handle the TableNewRow event of the DataTable.

   Good if you want to initialize with external values of some kind, but you can also attach the handler from inside the typed DataTable if you override the EndInit() method, which being part of ISupportInitialize, Visual Studio calls every time the table is initialized in a designer. If you use the dataset outside of the designer, well, you’re screwed.

   public partial class MyDataSet {
       public partial class MyTable {
           protected override void EndInit() {
               this.TableNewRow += (object sender, TableNewRowEventArgs e) => { // use 'delegate' if not C# 3.0
                   MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)e.Row;
                   row.ID = new Guid();
                   row.CreatedOn = DateTime.Now;
               };
               base.OnTableNewRow(e);
           }
       }
   }

4. Use a BindingSource and handle the AddingNew event.

   You bound your dataset to a bunch of controls, and now you want to create new rows with data that’s only available in your presentation tier. BindingSources let you control the row creation process completely if you handle the AddingNew event. The downside is that you have to create the whole thing manually, and to do that you have to know how BindingSources work.

   Another caveat is that the BindingSource’s Position won’t move to the newly created item, like it would otherwise. You’ll have to do that yourself.

   myBindingSource.AddingNew += (object sender, AddingNewEventArgs e) => {
       DataRowView view = ((DataView)myBindingSource.List).AddNew();
       MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)view.Row;
       row.ID = new Guid();
       row.CreatedOn = DateTime.Now;
       e.NewObject = view;
   }

   There’s a better way in which you don’t have to create the DataRowView…

5. Use a BindingSource and handle the ListChanged event.

   This is the easiest way to initialize rows directly on the BindingSource. Unlike the AddingNew method, the BindingSource creates the row, and sets the Position to the new item.

   myBindingSource.ListChanged += (object sender, ListChangedEventArgs e) => {
       if (e.ListChangedType == ListChangedType.ItemAdded) {
           DataRowView view = (DataRowView)myBindingSource[e.NewIndex];
           if (view.IsNew) { // Check if the row is in its detached state
               MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)view.Row
               row.ID = new Guid();
               row.CreatedOn = DateTime.Now;
               bs.ResetItem(e.NewIndex); // this is needed to get the controls to show the new values that we just set.
           }
       }
   }

   The ListChanged event is called twice. First when the row is created in its detached state, and then again when it’s added to the Rows collection of the DataTable. We only need to handle it the first time. The call to ResetItem will make sure that all the bound controls read the new values.

6. Use control-specific events.

   Some controls have their own events to initialize new rows. I don’t recommend using this approach, because it’s too control-specific. It’s much more interoperable to initialize at the BindingSource. You never know how that AddNew might be called.

Depending on what kind of data you’re initializing, and in which tier, you might need to mix and match. #4 for the data tier and #6 for the forms do the job for me.

I am not the only one.

Nifty.

[15-Oct-2008 04:52:15] b2evolution error: MySQL error! / Duplicate entry 'c-events-are-accessors' for key 2(Errno=1062) / Your query: DataObject::dbinsert()INSERT INTO evo_items__item (post_datestart, post_creator_user_ID, post_notifications_status, post_renderers, post_status, post_locale, post_priority, post_main_cat_ID, post_ptyp_ID, post_url, post_excerpt, post_urltitle, post_comment_status, post_title, post_content, post_wordcount, post_datecreated, post_datemodified, post_lastedit_user_ID) / VALUES ('2008-10-15 12:52:14', '1', 'noreq', 'b2evSmil.b2evALnk.evo_videoplug.b2WPAutP.evo_code', 'draft', 'en-US', '3', 16, 1, '', '', 'c-events-are-accessors', 'open', 'C# events are accessors', 'An interesting feature of C# I discovered recently is that events are actually accessors, [...] is', 60, '2008-10-15 12:52:14', '2008-10-15 12:52:14', 1) in /home/sonic12/public_html/sunstormlabs/inc/_core/model/db/_db.class.php at line 568 / REQUEST_URI: /admin.php / HTTP_REFERER: http://www.sunstormlabs.net/admin.php?ctrl=items&action=new&blog=1
[30-Oct-2008 04:51:01] XML error: Invalid document end at line 2, column 1

Being patient with software faggotry like the programmer I am, I promptly fixed the error by installing WordPress.

I was fed up with b2evolution anyway. It was doing a lot of stuff that I didn’t care for, and wasn’t doing a lot of stuff that I did want. It had support for multiple blogs for people with MPD, and statistics rendered useless by Analytics, but it also had some 3 good (ie: not fixed width) skins available, couldn’t do comments and their formatting right, had at least 3 URLs for everything, wasn’t very friendly about posting images, no decent syntax highlighting plugin, and I was feeling left out of all the WordPress feature wanking I keep seeing on other blogs.

The irony is that I picked b2evo in the first place because it wasn’t WordPress and I wanted to be different. No matter how much I try to convince myself that “alternative” doesn’t mean “worse” in every possible context, 10 out of 10.1 times I get a cockslap to the face. Why do I bother?

private string myData;
public string MyData // A property
{
  get { return myData; } // called when the property is read
  set { myData = value; } // called when the property is written to
}
 
private EventHandler myDataChanged;
public event EventHandler MyDataChanged // An event
{
  add { myDataChanged = (EventHandler)Delegate.Combine( myDataChanged, value ); } // called when a handler is attached
  remove { myDataChanged = (EventHandler)Delegate.Remove( myDataChanged, value ); } // called when a handler is detached
}

A vanilla event declaration, without the accessors, does this internally. It also acquires a lock every time it accesses the EventHandler to be thread safe, which we’re not doing here, and you should, if you need the safety.

A great application of this is to simulate “bubble” events in WinForms like in ASP.NET. Take for example a form with a user control with a button in it. If I wanted to receive the button’s click event on the form, I would have to either expose the button, or handle its event in the control, and raise a different one on the control:

public class MyControl : UserControl
{
  public event EventHandler MyButtonClick;
  Button btn;
 
  public MyControl()
  {
    btn = new Button();
    btn.Click += new EventHandler( btn_Click );
  }
 
  private void myBtn_Click( object sender, EventArgs e )
  {
    if ( MyButtonClick != null )
      MyButtonClick( sender, e );
  }
}
 
public class MyForm : Form
{
  MyControl ctl;
 
  public Form()
  {
    ctl = new MyControl();
    ctl.MyButtonClick += new EventHandler( ctl_MyButtonClick );
  }
 
  private void ctl_MyButtonClick( object sender, EventArgs e )
  {
    // Button clicked on the control!
  }
}

This can get rather bothersome and ugly if you have many buttons. Using an event accessor you can take the handler and attach it to anything you like, so you can just pass-through the handler directly to the button(s).

public class MyControl : UserControl
{
  Button btn;
 
  public MyControl()
  {
    btn = new Button();
  }
 
  public event EventHandler MyButtonClick
  {
    add { btn.Click += value; }
    remove { btn.Click -= value; }
  }
}

There’s one caveat to this technique, and that’s when you handle the event somewhere upstream, the “sender” would be the button, not the MyControl. This might break encapsulation, and if that’s important to you, the handle/re-raise method is the way to go.

Note: Don’t try this at home. It WILL irrevocably void your warranty, and you can easily cause permanent damage to the keyboard.

First, we need to unscrew all the screws on the bottom plate. The top plate is also locked down by a bunch of plastic hooks, which can be pulled back with the help of a thin screwdriver. Be careful with the silver plastic, since it scratches very easily.

The LCD is attached to the top cover with a small FPCB to the main circuit. It can be removed by pulling up the little clamp that holds it in the socket.

All of the important electronics are at the top of the keyboard. It’s rare for the electronics to break during a spill since most of the water gets on the keys themselves. Our next task is to remove the silver plastic panel, the one on which all the keys are.

First, it has to be unscrewed. The clear plastic bits that go under it also unscrew at the top, and the FPCB connections can be carefully detached by easing them out of their sockets.

Again, there are plastic hooks holding it in place. These are easier to go around. The bottom ones can be released by bending and twisting the keyboard a bit, and if not there are a handy set of holes one can use to get to them with a thin screwdriver.

This should get the keyplate separated from the keyboard.

Underneath it, we can see a clear plastic plate and the LEDs used for backlighting the keys. Some of it’s wet; I’m on the right track. The real problem lies under it though, so lets get that off too.

The backlighting LEDs and their circuits sit in the gaps in the plastic. All those litle white dots diffuse the LED light all over the keyboard.

Beneath it, we have a flexible PCB printed on a transparent substrate. This is what detects keystrokes. It’s made up of three layers. All those little lines are a very thin layer of conductive material. The middle layer is just a separator that keeps them separated until a key pushes them together. Every top-bottom combination is unique, and when they’re connected, the keyboard can figure out which key’s being pressed.

What pushes them together is this rubber membrane, which also makes the keys pop back up after being pressed.

The problem with this, is that these FPCBs are extremely easy to erode with liquids. Having killed a Saitek Eclipse keyboard before by spilling stuff on it, I already know what to look for…

Dirty, dissolved or corroded connections. This spells doom for all any any keys that they connect to. I’m still trying to find a good way to clean these that’ll keep them intact, and I’m not sure if it’s even possible. A wet cotton Q-tip seems to do the job, but it’s important not to use any cleaning products, because they melt the connections right off.

They can be easily tested with a multimeter. Most have a setting that will beep if there’s a connection.

Those top connections are definately dead. Just my luck, these control the space bar, the letters A, Z, and parts of the keypad. Not exactly ignorable.

I’ve called Logitech, and they don’t sell separate parts. So I either fix it, or get a new keyboard.

Last time, I tried to repair the Saitek using liquid silver. However, the way it is, it’s hard to apply and takes ages to dry, and, well, didn’t work. This time I want to try a silver ink pen, which is claimed to be the same, but easier to use.

I’ve ordered one off eBay. While it doesn’t come in, I’ll be using a generic crapo-cheapo keyboard.

Exciting conclusion coming soon.

For the most part, that’s true, to the point that standard MP3s cover most peoples’ listening needs. I’ve happily built up a 40+GB MP3 library for several years because of this. But only to a point. My opinion changed when I discovered FLAC.

FLAC stands for Free Lossless Audio Codec, an audio format similar to MP3, but lossless, meaning that audio is compressed in FLAC without any loss in quality. This is similar to how Zip works, except with FLAC you will get much better compression because it is designed specifically for audio[...]

MP3 is a lossy format. That means that in order to reduce the size of the music file, an MP3 encoder will actually chop off parts of the sound. Like a JPEG, it gets away with this, because the parts that it cuts off are the ones that you are least expected to miss, such as frequencies that aren’t audible by the human ear. Depending on the bitrate of the file, it can be more or less zealous in cropping down the sounds.

FLAC is lossless, which means that it keeps everything, exactly as in the original. When ripped from your standard Red Book CD, that’s a mighty 1411.2 kbps of pure, unadulterated sound.

MP3-FLAC comparison

An easy demonstration of just how much of a difference that is, is simply to listen to it. I took the above image from a MP3/FLAC comparison, made by someone that knows more about this than me, that shows what you get if you subtract the sound of an MP3 recording from the original source. I was quite astonished when I heard it, because there’s just so much sound getting cut! Even taking in account psychoacoustics, there’s just too much to convince me that the difference is indistinguishable.

It seems that this is a pointless argument, unless you can actually prove that you can hear the difference with an ABX double blind test (bringing it up on an enthusiast forum is sure to bring forth a barrage of furiously masturbating people which will quickly point this out). And while I didn’t go as far as setting up a scientific experiment, I fell in love with FLAC because I can’t help but notice that when compared to commercial grade MP3s, for a lot of music, it does make a significant difference.

You can really appreciate the increase in resolution. All the subtle and intricate background effects like drum riffs and beats, become sharp and well defined, with the sound’s “contour” much easier to distinguish. Voices sound clearer and with more depth. You even start noticing things like the sound of the singer’s breathing. Everything gets more “oomph” to it. You can almost feel, even if not hear, all of the supposedly “inaudible” frequencies, and the sound becomes a lot more friendly to high volume listening. And what astounds me the most is that FLACs actually let me hear parts and effects of the music, which I simply previously didn’t know of at all. Things like stereo effects, subtle modulations, little sounds and decorations, and so many more tiny things. It’s almost like rediscovering my favorite music all over again.

Of course, it depends on the music. There are some things that are worth it, and others that aren’t. A lot of music doesn’t need all that quality because it doesn’t actually make use of all of the resolution. But if you take something like the rich and deep sounds and vocals of Muse, or the addictive electronic pulse of Daft Punk, or just about any live recordings, and FLAC completely blows MP3 out of the water.

Daft Punk in concert

And of course, you actually need a decent sound rig to be able to produce the difference in the first place. If you have an integrated sound card, and basic computer speakers, you’re not going to get much more than MP3 has to offer anyway. Despite all the wild claims of being “Ultra Clear 3D Hi-Fi Xtreme!” that chipset manufacturers make, all integrated sound cards sound like utter crap, even for basic things. I’ve checked this with every motherboard I’ve owned, and always ended up disappointed. I personally have a Creative X-Fi rigged up to an old Technics SADX850 living room amplifier that I confiscated from my parents for never using. That’s connected to a pair of large, 80 watt front speakers, and three smaller satellites for surround.

I still lack a dedicated subwoofer, so I also linked it with an old Creative 2.1 speaker set for the bass. It’s not the best approach, and any real audiophile will wince at the sight of it, but it works quite well. I have a large room to fill with sound, and most computer speakers are designed for covering a small range. At full volume, my rig can be heard two floors down. This is where FLAC really shines.

All of this isn’t really a compression problem as much as a publishing problem. Keep in mind I’m comparing FLACs with the kind of MP3s one would normally own – commercial grade MP3s, not handcrafted laboratory MP3s. You can certainly get a lot more from MP3s if you know what you’re doing and rip them yourself from the original, with the right codecs and the right settings. However, Most MP3s are either downloaded straight from the internet (and judging by the growth of the digital music industry, that tendency will keep growing), or ripped using Media Player, or some other consumer software.

I’ve worked for two years at MusicaOnline, a digital music shop in Portugal. The usual “process” for publishing digital music isn’t exactly refined. The way things are done, you can easily end up with a “320 kbps” file, that got artificially padded up from a 128 kbps WMP/iTunes rip, and was re-encoded half a dozen times by an automated encoding server. I’ve seen this happen in front of me, and it made me cringe. This wouldn’t happen if the music got encoded in FLAC, since there’s no way to rip it in a way that affects the quality of the resulting audio. No matter how you do it, you still get all the same data.

The main reason that lossless methods aren’t widespread yet is that FLAC files are on average 4 or 5 times bigger than their 320 kbps MP3 counterparts. An entire CD can easily cost you ~400MB of disk space, plus the increased download time, if you’re not ripping it yourself. Its size isn’t friendly to portables either, and because of that, FLAC doesn’t have the widespread hardware support that MP3 enjoys either. There’s only a handful of portable players that can handle it, but the list is growing.

It’s also very hard to find digital music stores that sell lossless music, and as usual, it’s file sharing networks that are leading the way. If you feel that some music could make use of FLAC’s increased quality, then you can usually find it on a torrent search. Provided you actually bought the music, obviously.

The size of FLACs doesn’t intimidate me. Disk space doesn’t cost much, and drive capacities are counted in terabytes these days. Broadband internet has become widespread as well. We already waste tons of bandwidth on HDTV just so we can inspect the pores on actors’ faces, so why not increase the quality of my audio content as well?

In any case, now that FLAC’s popularity is increasing and FLAC rips are becoming easier to come by, I’ve started to migrate parts of my library to it. It’s still a painful process because of the size and availability, but so far it’s been paying off. I’ve been enjoying a lot of music all over again, on a whole different level, and it’s just awesome. So if you love music as much as I do, give FLAC a try. You might find yourself surprised at all the things you’ve been missing.

If I can, I try to avoid scripting completely. In the current state of browser affairs, I don’t feel like I can rely on Javascript for anything more than decoration and minor UI enhancements. When I do have to work with Javascript (and by that I mean any client side scripting language), I do it in a very conservative, “1.0″ way.

This post explains my feelings well, and even goes as far as to propose the term “JUE”, for “Javascript Usability Enhancement”:

AJAX [Javascript on the whole], should only be implemented after the page has complete functionality, and should only be used to enhance the usability of the webpage. Every function which is possible through the AJAX, should also be possible in the same or similar way without the AJAX (but usually with an extra page-load or two).

This isn’t just about usabilty, unobtrusiveness, or separation of code though. There are plenty of advantages on starting from the server side and working your way up. Some of my favorites are…

• Security: You can’t rely on client side validation because it’s so easy to by pass that even my computer illiterate mother accidentally does it on occasion. HTTP is an open protocol; it’s stupid to think that well behaved, Javascript-running browsers are the only thing that can get my pages. 
• Compatibility: Static HTML makes very few assumptions about the environment it’s in. It just tells the client of the information it wants to pass along, and lets the client figure out how it wants to render that. This makes it the lowest common denominator for the Web. Javascript, on the other hand, makes a lot of assumptions. Any scripting will only work well in the environment it was written for, while static HTML has a much greater reach.
• Transparency: Static HTML is the closest thing to the true model of the web, while scripting is a higher level layer over it. Focusing primarily on scripting makes it that much easier to miss the right way to do things under the web model, especially for someone for the people that don’t know what they’re doing.
• Purpose: Javascript is designed to manipulate bits of document. The fact that it grew into into a full blown UI framework is a mind boggling technological abomination. If you realy want to make a rich, web-based application, why not use something designed for rich UIs, like Flash or Silverlight?
• Performance: Despite all its recent advances, browser scripting performance still doesn’t hold a candle to desktop applications in terms of speed and responsiveness. Static HTML is still what browsers were designed for, and the features that it supports will always have the best performance. While a static HTML interface might not be as feature rich as a scripted one, its endurance shows that it’s good enough to be efficient. Being used to the efficiency of static interfaces, the added weight of all of the “rich” interfaces makes for an uncomfortably noticeable break in flow.

But despite all that, scripting does help address the very real, and always increasing need for rich interfaces on the web. If used right, scripting can have great results for a lot of people.

The real reason why I don’t like client side scripting is because Javascript, and the way it’s designed, doesn’t make it easy to do anything worthwhile. Take the fact that it’s modeled as a low level interface for document manipulation, add the problems that come from browser inconsistencies, top it off with poor debugging and IDE support, and you got yourself a clusterfuck that can be only beaten by the current state of CSS. Every time I pick up Javascript, it’s a productivity struggle of monumental proportions.

Javascript is like the C++ of web programming: very flexible, but too low level to be adequately productive. So the solution is not to use it at its lowest level, just like I don’t use Win32 in my apps when I want to get things done. It turns out that there are tons of great libraries that already implement all of those things that you would have to do over and over again in Javascript.

I suppose I should have thought of it before, that maybe a million people have already done this a million times before, and maybe some of those people put it together in a way that takes away the need for me to do for the millionth-first time. I guess I just never saw Javascript as a serious enough language to make “libraries” for. Back when I started, Javascript “libraries” were the things you copypaste from Javascripts.com to make gay rainbows on your text.

The problem is, every time I tried to research Javascript or AJAX, I always find tons of resources, merrily spewing forth explanations on how to use document.getElementById(), make XMLHttpRequests, or animate things using setTimeout and setInterval, and enumerating the myriads of caveats and their workarounds between browsers. Not once I’ve seen a site stop, and tell me “Hey, you! You’re doing stuff that’s already been done a million times! Why not just use a library that handles all of this for you?”

Point in case, I was recently asked to do a small widget that cycles images, “like the thing on Yahoo Movies“. After several hours of browsing sites that explained in great detail all the pages of code I would have to do, and tons of custom implementations of said code that did almost kinda what I wanted, I came across JQuery. And it felt like God almighty came down in an angelic choir, and slapped the Truth into my face with a tire iron. I was enlightened.

JQuery delivered an excelent first impression. Having had no previous experience with it whatsoever, it took me 10 minutes, and a grand total of two lines of code to make my animated scroller. It already had everything done for me, starting from a CSS-like element finder syntax, to automatic tweening of any value. I don’t usually enjoy adding non-standard, external libraries to my code, but this one of those things that really should be standard, and only isn’t because all the other JS toolkits would cry their eyes out.

It seems Javascript coders suffer a lot from the “Not Invented Here” syndrome. Maybe it’s because you don’t need anything but a browser to write Javascript. Maybe watching your page come to life after all of that hard work is very satisfying. Maybe they’re afraid that if someone looks at their code and sees them use a library, they won’t seem as hardcore. Or maybe someone just needs to clean up the internet of all of the feces that the last generation of Javascripters left behind.

I, however, don’t have the patience for it. From now on, I’ll just be dropping JQuery into all of my projects.