Web Application Development Tips, Tricks and Techniques
Object Oriented JavaScript II: the pattern
Dec 21st
Ok, now that we’ve covered the most basic concepts of JavaScript, we can now proceed to take a look at the pattern itself.
The first feature we need to implement is private and public members. Using closures, this is easy to achieve:
Object Oriented JavaScript I: the basics
Dec 2nd
Today’s web applications are inconceivable without the use of JavaScript. It has become a fundamental part in modern web systems. A lot of time and effort must be put into client-side programming to make our application have that modern look & feel that JavaScript provides and we all like to see.
Until AJAX techniques emerged, JavaScript was not seen as an application development platform. It was treated merely as a scripting language to implement minimal dynamic web page behavior. Up till not too long ago, all the JavaScript I needed to write was just a few lines of code to make some validations, a few animations and some AJAX calls… but this has definitely changed today. The number of JavaScript lines I am writing nowadays for the web apps I’m developing are counted in the thousands. Heck, the last module I developed at work contained more than 12000 lines of JavaScript code! This means that I can no longer just write code without order. I need to have some logic behind the process of writing code. And this is when object oriented techniques come into play.
Load testing
Oct 21st
There are different kinds of testing any application must have passed before releasing it to the public. We’ve already taken a look at Unit testing and GUI Testing. But another important kind of test you should test your application against is Load testing. Having undertaken and passed these three different kinds of testing will ensure you’ll have a rock-solid application that will meet the highest quality criteria.
Load tests are designed to check how fast a system can perform its tasks under certain work conditions. They also verify some other attributes, like scalability, reliability and an efficient use of resources. These tests can find which parts of the system make the whole application perform worse than expected. If all components of the system are independently monitored (database, web server, etc…), finding the bottleneck of the system won’t be difficult. And just by tuning this part of the application, you’ll make your whole system faster. Doesn’t this sound beautiful?
GUI Testing
Oct 4th
A very important thing you must do before releasing your web application into the wild is some sort of Graphical User Interface Testing. This kind of testing ensures that the interfaces between the client and servers execute in tandem. It is an important factor that these connections or interfaces work seamlessly without any failure or degradation in performance of speed and accuracy. The testing should also check for appropriate error messages. So, you must design these tests not only to check whether your application works as expected, but also to ensure that the performance is good enough.
Unit testing
Aug 3rd
A unit test is a piece of code written with the sole intention of verifying that a routine or function behaves as we’re expecting it to. Unit testing attempts to provide a collection of tests to check every method of the different classes the developed program may contain works flawlessly. The general idea is that, if all the parts of the program work properly independently, it’s highly likely that the program as a whole will function as expected. Of course, after all the unit tests are passed, integration tests must be performed as well to ensure the complete system doesn’t have any unintended behavior.
Improving software quality: automatic testing
Jul 13th
Providing high quality software from early stages in the software project is the key to a successful project. We must check the quality of our software in every single release and make sure it’s meeting our expectations. It’s much easier to code having quality requirements in mind from the very beginning than finishing a module and then fixing all the unexpected behavior afterwards.
There are many tools to improve the quality of our work. Developers have refactoring tools, memory profilers, code coverage, etc. But in a software project we also have testing resources, also known as Quality Assurance. Their job is to test the application and find as many bugs as possible: to achieve a high quality product, thorough testing is a very important step. However, this can be a very tedious and time-consuming task. Fortunately, part of this work can be performed automatically using some tools.
Software design patterns (IV): behavioral patterns
Jan 12th
We’ve already been through a brief introduction to design patterns, and a description of the most important creational design patterns and structural design patterns. In this article we’ll take a look at the last category of design patterns: behavioral patterns.
Behavioral design patterns are concerned with the relationships among communications using different objects. They identify common communication patterns and provide a well-known solution to implement this communication, offering a higher degree of flexibility.
The most used behavioral patterns are:
Software design patterns (III): structural patterns
Jan 5th
We already saw what design patterns are and took a look at creational patterns in earlier articles. Today we’ll deal with the second category: structural patterns.
These design patterns are all about class and object composition. Class-creation patterns use inheritance to compose interfaces, whilst object patterns define ways to compose objects to obtain new functionality. All of these patterns aim to ease the design by identifying a simple way to realize relationships between entities.
The most common structural patterns are:
Software design patterns (II): creational patterns
Dec 15th
In an earlier article we saw what design patterns are and how they can help us. Today we’re going to take a look at the first category: creational patterns.
Creational design patterns deal with class creation and instantiation, and how to use those instances. Basic class creation could result in design problems or added complexity to the design. These patterns solve these problems by controlling this object creation.
Some examples of creational design patterns:
Software design patterns (I)
Dec 8th
Design patterns are solutions to common software development problems, and aim to facilitate the development of a software project. A solution must have proven effectiveness and be highly reusable (can be applied to different design problems in different circumstances) to become a design pattern.
A pattern describes a problem that happens over and over again in our environment, and then explains the core of the solution to that particular problem. Since it is just a scheme of the solution, the application of this pattern is not literal: it requires adaptation. You could use the same pattern a thousand times, and never repeat the way you applied it.
My name is Oliver Mezquita Prieto, and I'm a Software Engineer focused on web application development, both serverside and clientside, using ASP.NET technology.
Got something to say? Drop me a line!