1. Help out with the MVC Turbine docs
2. Finish my Ringbinder project and release it
3. Write a simple little app for use at home in either Clojure or Smalltalk
4. Continue to learn Python
5. Write a small app that runs on the Google App Engine
6. Write a blog post, either here or on my work blog, at least once a week
7. Redesign this blog
8. Work on and launch the coderdads.info site I’ve had in mind for a while

I’m sure I’ll come up with more as the year progresses and I, hopefully, finish up these tasks.

My template looks like this:

PLAIN TEXT

CODE:

1. <script id="ItemTemplate" type="text/html"
2.         <li class="item" value="|rowNumber|">
3.               <input type=”text” id=”input|rowNumber|” />
4.         </li>
5.     </script>

Now within my code I need to put a place holder where I want my HTML to go. I have my unordered list called url_list.

PLAIN TEXT

CODE:

1. <ul id="url_list"></ul>

Now, you see that most of my items look like this “|rowNumber|” I have a variable in my code called nextUniqueItemID (I believe in extremely descriptive variable names). Here is my “addItem” function.

PLAIN TEXT

JAVASCRIPT:

1. function addItem() {
2.         var list = $('#url_list'),
3.                       items = list.find('li');
4.         list.append($('#ItemTemplate’)
5.                                     .html().replace(/\|rowNumber\|/gi, nextUniqueItemID++))
6.     }

The use of global variables aside (cough,cough),I looked at it and, having used something like this myself, thought that it would work find for data sets containing a very small number of items. The problem is these kinds of clone based templates are VERY slow compared to the templating engines that are available for various JavaScript libraries.

I happened to read a post by Brian Landau called "Benchmarking Javascript Templating Libraries" this morning and wondered just HOW MUCH slower is the naive template method than a good template library?

I grabbed the benchmarking code and modified it to run the new clone based template method.

Since the template Sara provided contains an input tag you get a different benchmark if you run the simple_test and the loop_test separately after refreshing your browser. You can run the tests for yourself here, the loop test *may* cause your browser to give you a "script is running slow" message, hit continue as the loop will eventually end. You may also get different numbers if you run the tests in IE, Chrome, and Safari.

results: using FF 3.5.5
Simple Test: 1.71s
Loop test: 31.534s

When you consider that the slowest loop test using a template library was just around 4.5s, you get a better idea of just how slow this method is when you have an input in your template.

So that's fine, but it's known that dynamically adding text inputs is slow in just about every browser and the original tests don't use inputs at all, just divs. So let's modify the template and see what the results are.

I modified the addItem function to account for the new data. n.b. The data I'm using is static, if you wanted to use a data source you would just modify this method to take in your data parameters.

results using FF 3.5.5 - refresh between each test
simple test: 1.285s
loop test: 3.771

results using ff 3.5.5 with no refresh between tests
simple test: 1.434
loop test: 4.227

So that's looking a little bit better. Not too much slower than the template libraries.

So what do the template libraries give you? Well the replace method works find provides your data is escaped properly. But say instead of a url in the "source" replacement, you use a file path like "file:\\foodrive\source.txt". Well it still gets replaced, but the text looks like this "file:\foodrivesource.txt". So in addition to the replacement, you have to make sure your data is properly escaped. A lot of template libraries will do this for you. Also notice that the addItem method has to do a DOM lookup on every iteration of the loop to get the template. If you have a large DOM, this could impact the performance.

But I'm wondering, can any use of programming language really be called abuse? The language designers and creators put the ability to create the hack described above into the language. If they didn't want you to do things like that, why put the ability in there at all? Using undocumented calls within the language to do strange things is one thing, but simply using calls within the language itself?

What are some of the best "abuses" you've seen of a language?

Mainly, it's for my personal benefit. I wanted to have a single source for my ASP.NET MVC news but Google searches pulled in a bunch of "why MVC isn't for me" type of posts, which I don't really care about. Those people are just wrong.

You can find it here. It may eventually get it's own domain and a nifty theme.

Planet ASP.NET MVC

Big-IP 10.1 has been released announced. It includes a lot of new features and enhancements to some existing features.

You can read some of the press releases on our main news page:

F5 Delivers Advanced Web Security Solutions to Help Customers Efficiently Address Threats to Web Applications and Enhance Business Performance

F5's BIG-IP Solution Enables Service Providers to Transparently Scale and Grow Mobile Services

F5 Enhances IP Geolocation Capability through Partnership with Quova

F5 Solutions Optimize Microsoft Windows 7 and Windows Server 2008 R2 Deployments

Enhanced support for Windows 7 and Windows Server 2008 R2.

Direct Access and BranchCache

Microsoft DirectAccess lets Windows 7 clients create a secure connection directly to the network over IPsec rather than having to create a separate VPN connection. That means that you can still access your files securely while you are enjoying coffee and a scone at Starbuck Joe wrote a great article addressing how Big-IP 10.1 helps enable DirectAccess using Windows 7 clients with Windows Server 2008 R2 servers in your enterprise. BranchCache is a new feature in Windows 7 and Windows Server 2008 R2 that will cache content from remote servers on local servers. You can access the file once it is cached as if you were working in the remote office, using less WAN bandwidth and wasting less of your time. BranchCache can work in one of two modes: Hosted cache mode and Distributed Cache mode. In hosted mode, a Windows Server 2008 R2 server will host the cached content. In Distributed mode the clients will host the cached content. Big-IP v10.1 will route the file requests to the correct server or client.

Security

DNSSEC

Lori wrote a great post about what DNSSEC is and how it works, “It’s DNSSEC Not DNSSUX”, and Jason posted an article explaining how to configure the new DNS features using both the GUI and TMSH. Configuring GTM Version 10.1's DNS Security Extensions

Advanced bot and scanner protection

Big-IP 10.1 includes support for detecting web site scraping and allows you to set thresholds for locking out IP addresses.

Enhanced reporting

ASM’s new Attack Expert System helps make sense of the attacks you see logged against your network. Each attack has a list of possible attack types and the types are explained. The reporting GUI has been reworked. You can either view a chart or drill down into the attacks with a few clicks. Ten-Point-One also includes a PCI compliance report.

Look for some more information about some of these features in the coming months.

(edited for clarity SCK)

I have a small battery powered Dremel rotary tool. It works for very small jobs. There have been a couple of times when I’ve had to push it way beyond it’s limit, including once when I needed to make the opening on a door jam for a strike plate a little wider. It took me forever. I had to charge the battery twice and broke a bit before I finally had enough room, but just barely enough room. Contrast that with the locksmith who had to do the exact same thing. He pulled out a much larger Dremel that plugged into the wall. Where it took me almost 45 minutes to rout out the door jam, he took about 2 minutes with his much more powerful tool. I could have stopped, went to the store, and bought a more powerful tool and gotten the job done much faster. But I thought that this tool would do the trick and going to the store would have cost me some resources, it might have taken a little longer. I’d have to learn how to use the new tool. Get a new bit. But overall, it probably would have saved me some time in the future and probably would have saved me some time on that project. I could definitely find other uses for the new tool.

Think about that the next time you reject a new programming tool because you think it might take too long to learn or it’s different. Instead of doing the hacky way you KNOW will work, check to see if there is a more elegant or permanent solution.  Because if you aren’t careful, your cheap and easy workaround might end up sticking around in the project long enough for it to become a problem to you.

And so for 20 years now these folks ---
*the* shining lights, in many ways, of "practical" programming
language, operating systems, and general systems research --- have
continued to fail to "get" the fundamental practical needs of everyday
programmers working in The Real World. "Go" is just another language
written first for the compiler and only secondarily for the programmer
--- and stuck in a 70s mindset* about the relationship of that
programmer to the (digital) world within which they live and work!
(But hey, it compiles fast! Which is, of course, THE problem that
really needs addressing.)

He then goes on to talk about some aspects of languages that frustrate him.

J.H.C, folks, it's nearly 2010. Let's get a few things straight:

- most programming involves schlepping a few but complex data types
between different string representations
- programmers have become plumbers and documentation-archaeologists
mostly, which is sad and uninteresting
- programming languages are for *programmers* --- not compilers and
compiler-writers
- until you make the everyday, "simple" things simple, it will
continue to be a dark art practiced by fewer and fewer
- any language that makes you explicitly import an IO module to
read a file or stdin is fucked
- declarations are a pointless anachronism (same for explicit
memory management)
- if I have to understand category theory to write a program that
does IO, IT IS A NON STARTER!
- less stupid line-noise syntax and punctuation, people

I don't understand why the need to compile fast is such a big deal. If your programming language makes you write so much code that it takes more than a few seconds to compile, you should probably look at using a different language. Here are some things that I'd like to see in a programming language that is designed for programmers rather than compilers or computers.

1) No typing - That's not to say that I can't declare my own types, classes, objects, etc... But that calls to objects should be type independent. (e.g. messaging and dynamic dispatch)

2) Built in unit testing - I should be able to declare contracts on the methods and pass/fail criteria. The tests should be run as part of the compile step or interpretation (if the language is compiled or interpreted)

3) Jellybeans

4) Automatic inclusion of libraries based on path and usage. - I don't mind having to pull in a library to do file I/O or consume some other kind of data like ATOM or JSON. But at compile time, if I have referenced any of the objects contained in the library, all of the references to the library should be handled for me automatically. Any name collisions should be compiler warnings so I can specify which library to use by in my code or make the reference explicit in some other way. I like Pythons path based module convention, the language should just search the child directories for a library if the library isn't already included in the base language pack.

5) Anytime a design pattern emerges, it should be re-factored into the language itself.

6) It should be a pocket language, have a set of keywords and syntax that is small and compact but still understandable. JavaScript and C are good examples of pocket languages. It's easy to pick up the syntax.

I'm sure there's more that I would add. What kinds of features would you like to see in a language oriented towards programmers rather than compilers?

Because the hardware they use could influence my application architecture.

• If I know the IT guys are able to bring in new servers in response to increased demand, I start to think about distributed caching instead of replication maybe. I start to think that the application shouldn't store any data in a machine specific session so that the load balancer can send the user to any machine.
• If they have access to distributed hardware caching, maybe I don't have to worry about donut caching in my pages.
• If I know they can pull servers in and out of the clusters at will with no visible downtime to our users, I start to think about deploying more often. I can become more agile.
• If I don’t have to worry about how much space is left where I’m storing my users uploads, I don’t have to write code to check how much space is available and present an error to my users if the space fills up.

One of my goals with my F5 Devcentral blog is to explore ways that developers and IT professionals can cooperate more and blur the lines between them a bit more.

Folks, this isn’t hard. In fact, both of these things are so simple I simply call it “using the programming language”.

Let’s look at dependency injection.

See the reader variable? That's a dependency. You have to have it in there to do fun things later on. But we have to create it ourselves, which is one more thing that we have to do in our class constructor. In reality we also have to populate the DataTable. So what if we make the reader variable constructor parameter so that another class can do the work of creating the DataTable and the reader?

There, that's better. Now our class doesn't have to worry about creating the reader and the DataTable. This, in a nutshell, is dependency injection. It's not very complicated is it? We've made our class construction a little simpler and if we want to unit test this, we don't have to do any complicated mocking, we can just new up our own DataTableReader instance and populate it with whatever test data we want. If you run into any funny looking data in the DoStuffWithTheReader method, you know that you don't have to look in this class at all to see where the funny data is coming from, only in whatever method is creating this class and passing in the DataTableReader.

Now is there anyone who thinks that developers on their team would have trouble understanding passing in a parameter? Should they really be a developer if they do?

Ok, so let's look at inversion of control. The original definition of inversion of control I read was by Martin Fowler:

There's a big difference now in the flow of control between these programs - in particular the control of when the process_name and process_quest methods are called. In the command line form I control when these methods are called, but in the window example I don't. Instead I hand control over to the windowing system (with the Tk.mainloop command). It then decides when to call my methods, based on the bindings I made when creating the form. The control is inverted - it calls me rather me calling the framework. This phenomenon is Inversion of Control (also known as the Hollywood Principle - "Don't call us, we'll call you").

If you look at the previous example, you'll see that we have already inverted the control a bit just by using dependency injection. But the class still has a degree of control over WHAT concrete object is created, in this case a DataTableReader. What if we need to switch over to a SqlDataReader or an OleDbDataReader? Well, we could create three other classes that all take the specific type of data reader we might want to use. But that's a bad idea, you end up with the same logic spread all over the place. Instead we can use the IDataReader interface that all three classes implement.

Now our class not only doesn't have to worry about creating the DataTableReader, it doesn't even really care if it gets a DataTableReader at all. All it cares about is that the reader is referencing something that implements the IDataReader interface. This is a type of inversion of control. Most of the time people get confused between inversion of control and a container that enables inversion of control and dependency injection (like Ninject, StructureMap or Unity). You don't have to use a container to utilize these two techniques, it just makes it a little easier.

update:Also check out this great post "It’s all about the delivery"

update: I mistakingly thought it was hard to do D.I. in Python due to the inheritance mechanism in Python. Turns out, it's just as easy.

At some point that very simple manifesto turned into a set of “must have” tools, technologies, methodologies, and processes. Which I think defeats the purpose. You have to look at each tool and methodology and think “how does this help me build better software for my user?”

There is a very important paragraph at the bottom.

That is, while there is value in the items on the right, we value the items on the left more.

 

So let’s go through each line.

Individuals and interactions over processes and tools

These “story cards” are one way to increase the communication between individuals during their interactions. Gigantic requirement specifications don’t do anyone except other software engineers any good. The daily standup meeting that a lot of agile practioners adopt is one way to keep the team up to date and find out about possible problems as soon as possible.

Working software over comprehensive documentation

No matter what, you’d rather have an application that meets the users needs and helps them get stuff done easier than they could before you wrote their application. Chances are, if you need to write a lot of documentation, you’ll have to maintain it also. Most of the time documentation is only for other developers that will have to come along behind you and change the software to meet new user needs. What better way to communicate what the software is supposed to do than a bunch of executable code, e.g. unit/scenario/integration tests, that ensures the application does what it says it can do?

Customer collaboration over contract negotiation

By adopting techniques and tools that allow you to change direction quickly and confidently, you don’t need to “lock down requirements” before you start developing. If the requirements change, you’re code base and tools are flexible enough to handle the change. That’s where principles like S.O.L.I.D. come into play, they make your code base more flexible and responsive to change.

Responding to change over following a plan

How can you ensure that, as you change your software to respond to changes in the business or requirements, your software doesn’t break? Automated testing is one method. Continuous integration builds are another. These tools aren’t used by agile practitioners  because they want to feel cool, they are used to help them better respond to change. The story cards and backlog also help. You can re-prioritize your backlog to meet the businesses current needs. Since your iterations are short, and your stories are small, the overall impact to changing direction is minimized.

The fact that software development is complex, and that there is a lot of new things to learn. That there is ALWAYS something new to learn about software development, has NOTHING to do with agile practices. You’d have exactly the same problem keeping up if you practice agile or not. You might have an internal process where you work that allows you to respond to change quickly, it may even involve Microsoft Access!

There was a great post that Miguel De Icaza linked to on Twitter. “Every Ideology is Right”

What I mean by "right" is that is each one is responding to a genuine problem within human existence. And their prescriptions for how to deal with that problem "work," at least in the short term in limited circumstances.

Obviously, there are unforeseen consequences because each ideology looks at a limited aspect of reality, and then tries to apply its solution for that part of reality to ALL of reality. The important thing is to try to have your ideology "look" at as much of reality as possible.