Speed can be a major determining factor in whether you provide a good or bad user experience. High speed internet, constantly improved desktop hardware and our increasingly busy schedule has led many to develop a great deal of impatience with technology.

———————————————————————————————————————————————
To illustrate user impatience, please wait 60 seconds before proceeding to the next paragraph.
———————————————————————————————————————————————

When forced to wait an extensive period of time, many think ‘My computer at home doesn’t make me wait this long, so why should my phone?!’. They then look for a speedier alternative. Two general strategies for enhancing the user experience in this regard involves real speed and perceived speed.

Real speed is just what it sounds like. It is the actual time it takes to interact with the app, download data or process data. This speed can vary greatly depending on how things are developed. One way to improve here is by optimizing data. Images, for example, should always be optimized for a mobile device to reduce file size. Returning data from an external database? Don’t dump the entire database. Reduce the size of the data by only sending what is needed.

Many try to cut corners because something is already prepared for a desktop environment. So instead of tailoring things for the mobile device, they try to save some development cost by utilizing what they already have. However, this approach can end up providing the users with a slow user experience.

Perceived speed is how fast the user thinks things are going. We might optimize our data to the largest degree possible. However, at times the user might still feel like things are going slowly. There are a few things we can do to make the user think that things are moving along a bit faster than they really are.

First of all, always display a progress indicator or spinner. This lets the user know that the app isn’t just hanging while the data is downloading or processing. If possible, include more details like ‘Downloading files 9 of 14’, or something similar.

Another strategy is to let the app show the data that is available while the rest is downloading or processing. For example, imagine an app that downloads several rows of data. Each row contains an image downloaded from an external server. Rather than wait for all the images to fully download before presenting the data to the user, show the data that is available and download the images asynchronously.

Finally, a third strategy is loading data that the user will request before they actually request it (think Instant Pages). An example of when we might use this is in an image gallery. The user is only viewing one image at a time. However, we know what images are before and after what they are viewing. So we begin the download process of those images without the user even realizing it.

These strategies above do not increase the real speed of our application. It still takes the same amount of time to download the data, to process it and to display it for the user. What we are changing is how the user perceives the data flow.

By utilizing these and other strategies, we can give our mobile app a much more pleasing user experience. In conclusion, don’t be slow to adopt these approaches.

Enabling paging in a UIScrollView will allow you to have a nice ‘snap-to’ effect. It’s exactly what you see when using the Photo app. I recently wanted to utilize this effect while displaying multiple pages on the screen but ran into a few issues. Problems and solutions below. Also, you can picture any ‘pages’ that I make reference to will just display an image as content.

Problem 1 – Swipe Not Detected

Consider this: You have a page in the center of the screen. To the left you see half of another page and to the right you see half of another page. Setting this up should be easy. Uncheck ‘Clip Subviews’, check ‘Paging Enabled’ and set the frame to be the size of each page. Great, it all works! Except you can only swipe if touch begins in the center page. So if I start my swiping in one of the pages that is partly showing on the right or left then nothing would happen. While some would accept this as a mild annoyance and move on, not the perfectionists professionals at Accella!

Solution 1 – Swipe Detected

The solution to this problem involves placing the UIScrollView inside a UIView and overriding the hitTest method of the UIView to pass along the touch to the child UIScrollView. So start by subclassing the UIView, add a reference to the UIScrollView inside UIView and finally add the following code to your UIView subclass:

- (UIView *) hitTest:(CGPoint) point withEvent:(UIEvent *)event {
  if ([self pointInside:point withEvent:event]) {
    return scrollView;
  }
  return nil;
}

Problem 2 – I want more than three pages on the screen

I actually needed to display 7 small images on the screen at one time. It was a horizontal bar that was the full width of the screen and held about 50 pages. Things were working in that I could swipe anywhere in that bar and I did get my nice ‘snap-to’ effect from the paging. However, things were a little too rigid. I got the ‘snap-to’ effect but had no momentum with my swipe. Swiping would instantly stop at the nearest page when I lifted my finger.

Solution 2 – I guess I don’t want paging after all

I determined that paging isn’t really what I was trying to achieve. What I really wanted was to have normal swiping, but have the UIScrollView ‘snap-to’ the center of the nearest page once it stopped. So it was a combination of ‘snap-to’ and momentum. To achieve this I entirely removed my previous solution and turned off paging. At this point I had just a free scrolling UIScrollView.

What I then did was monitored the UIScrollView to determine when it started to slow down. If it slowed down to a certain point then I knew it was about to stop. At that point we just set the content offset and set animation to ‘YES’. This provides a seamless animation for the whole process. I also need to have the ‘snap-to’ effect when just dragging, but not necessarily swiping.

#pragma mark - UIScrollViewDelegate

// Note the width of my pages is set to 52px

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate {
    monitorVelocity = decelerate;
    currentTime = [[NSDate date] timeIntervalSince1970];
    prevTime = [[NSDate date] timeIntervalSince1970];
    currentPosition = pickerScrollView.contentOffset.x;
    prevPosition = pickerScrollView.contentOffset.x;
    
    if(!decelerate) {
        CGFloat offset = round(currentPosition/52)*52;
        // only snap-to if offset is within content bounds to prevent interference with the scrollviews bounce property
        if(currentPosition > 0 && offset < pickerScrollView.contentSize.width && currentPosition < pickerScrollView.contentSize.width-52) {
            [pickerScrollView setContentOffset:CGPointMake(offset,0) animated:YES];
        }
    }
}

- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    if (monitorVelocity) {
        currentTime = [[NSDate date] timeIntervalSince1970];
        currentPosition = pickerScrollView.contentOffset.x;
        float velocity = abs((currentPosition - prevPosition) / (currentTime - prevTime));
        prevTime = currentTime;
        prevPosition = currentPosition;
        
        if (velocity  10) {
            monitorVelocity = NO;
            CGFloat offset = round(currentPosition/52)*52;
            // only snap-to if offset is within content bounds to prevent interference with the scrollviews bounce property
            if(currentPosition > 0 && offset < pickerScrollView.contentSize.width && currentPosition < pickerScrollView.contentSize.width-52) {
                [pickerScrollView setContentOffset:CGPointMake(offset,0) animated:YES];
            }
        }
    }
}

Week 1 – Excitement

Going into my project I had an abundance of excitement. Stepping into this unknown territory was a huge adrenaline rush. I had never built a Blackberry app, had no Java experience and had not even used a Blackberry before. This would definitely be a challenge for me. Having a positive attitude is important for any project that you work on. A positive outlook will help you not give up when faced with problems. During the first week I didn’t really learn anything or make very much progress in the app development, but was still happy and optimistic about the project.

Week 2 – Despair

By week two I fully realized that blackberry development was nothing like I expected. Sure, I had the api documentation, but the developer community was very small, quite unlike the iPhone or Actionscript developer community. The api has many limitations. The way the UI is built is confusing and still irritates me. Overall I felt like I was building an app using a language that was old and dead. I began to make a little progress. However, I didn’t fully grasp how things worked.

Week 3 – Understanding

Progress started to flow much more rapidly in week three. I was finally beginning to understand a bit more about blackberry development. One of the most difficult things for me was figuring out how to develop the UI. My thinking here had previously been create an object, set its properties, give it some styling rules and finally position it. Doing this for the blackberry kind of makes me think of html tables. Layout of UI objects is done by using Managers. You can use HorizontalFieldManager (aka <tr>), VerticalFieldManager (aka <td>) or create your own Manager. Here my thinking had to shift from using a screen position for objects, to using a layout for objects. For many things, you could not just change the color of something or some other small change just by modifying a property of the object. Instead, you need to subclass the object or override some of the object methods. So overall, getting the app to look the way I wanted was much more involved and tedious than other languages that I’ve worked with. The sample apps provided by RIM, and a few of the apps that I seen on the device are just plain ugly. I guess the reason for that is it takes a lot of patience and effort to make something that looks decent.

Week 4 – Finishing Touches

The app was coming together. It was functioning properly, it looked good and all that remained was a few loose ends to finish the project. I needed to make a few design changes, implement some screen management and do some final tests on a device. After that was done I remembered that I’m developing for several devices and OS versions. I probably should have thought of that sooner. Thankfully, there were no major problems that I saw and was able to release the app on time.

Conclusion

I think I was able to take away several things from this project. First and most important: I personally hate Blackberry devices, despise their api and I hope soon Android and Apple will crush them into oblivion with their far superior and powerful devices and operating systems. However, as long as they are around and there is a demand for apps, I will continue to drag myself through the minefield that is Blackberry development. Secondly, this project helped me strengthen my adaptive programming muscles, which is always a good thing.

Lastly I want to offer a bit of encouragement to you. Are you working on developing your first blackberry app but on the brink of giving up because it’s just too much of a daunting task for one person? Are you needing an app built but finding it difficult to find a competent team of professionals? If you answered ‘yes’ to either of those questions then I would like to encourage you to contact the best mobile development team in the entire world at Accella.

Problem 1 – Cannot find javaw

After running through the installation and trying to start the JDE, I received an error message saying ‘cannot find javaw’. That was odd to me because I was sure I had JDK installed. The problem was that the Blackberry JDE is not compatible with the 64-bit version of JDK, which is what I had. However, after downloading the 32-bit version of JDK, I found a second problem.

Problem 2 – Cannot find RIMIDEWin32Util.dll

Now I was confused. I was certain I had everything installed properly, but I was still receiving errors. A few forum posts suggested setting path and javahome to their full locations. Open up the following file:

C:\Program Files (x86)\Research In Motion\BlackBerry JDE 6.0.0\bin\ide.bat

Once opened we are going to add 2 lines to the beginning of the file. Change the file from this:

start javaw -Xmx1024M -DRIM_RUNTIME=..\lib -DRIM_BIN=..\bin -jar IDE.jar

to this:

SET PATH=C:\Program Files (x86)\Java\jdk1.6.0_22\bin;%PATH%
SET JAVAHOME=C:\Program Files (x86)\Java\jdk1.6.0_22
start javaw -Xmx1024M -DRIM_RUNTIME=..\lib -DRIM_BIN=..\bin -jar IDE.jar

Save, close and try to start the JDE. This time you should be error free.

(UPDATE: Example code below now more extensive and bug free. Example project can be downloaded at end of article.)

Duplicate end caps

The first option is best suited for smaller loops. Suppose you have ten photos to display. When the user is on photo one and swipes left, it will take the user to photo ten. When the user is on photo ten and swipes right, it will take the user to photo one. The logic we will follow here is to add photos in order, but place an duplicate of photo ten to the left of photo one and a duplicate of photo one to the right of photo ten.

Now when the user scrolls to the end, we reposition the content offset of our UIScrollView. By having a duplicate photo at the end and repositioning the offset without using animation, we create a seamless experience for the user.

- (void)scrollViewDidEndDecelerating:(UIScrollView *)sender {
    // The key is repositioning without animation
    if (scrollView.contentOffset.x == 0) {
        // user is scrolling to the left from image 1 to image 10.
        // reposition offset to show image 10 that is on the right in the scroll view
        [scrollView scrollRectToVisible:CGRectMake(3520,0,320,480) animated:NO];
    }
    else if (scrollView.contentOffset.x == 3840) {
        // user is scrolling to the right from image 10 to image 1.
        // reposition offset to show image 1 that is on the left in the scroll view
        [scrollView scrollRectToVisible:CGRectMake(320,0,320,480) animated:NO];
    }
}

3 Pages Only

There may be times when you want an infinite page loop, but don’t want to load in a lot of content. For example, I recently worked on a project that displayed a different document with an image and text for every day of the year. The client wanted an infinite page loop so that the user would be able to scroll through the documents. However, that would be far too much data to load into a UIScrollView all at once. A different approach was needed.

The logic that I used was to keep the UIScrollView at just three pages. A document would load on each page and the user would always be looking at the document in the middle page. When the user scrolled to a new page, the content for each document would be reset and the offset would go back the user is back to viewing the middle page.

- (void)viewDidLoad {
    [super viewDidLoad];

        documentTitles = [[NSMutableArray alloc] init];

        // create our array of documents
        for (int i = 0; i < 10; i++) {
                [documentTitles addObject:[NSString stringWithFormat:@"Document %i",i+1]];
        }

        // create placeholders for each of our documents
        pageOneDoc = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 320, 44)];
        pageTwoDoc = [[UILabel alloc] initWithFrame:CGRectMake(320, 0, 320, 44)];
        pageThreeDoc = [[UILabel alloc] initWithFrame:CGRectMake(640, 0, 320, 44)];

        pageOneDoc.textAlignment = UITextAlignmentCenter;
        pageTwoDoc.textAlignment = UITextAlignmentCenter;
        pageThreeDoc.textAlignment = UITextAlignmentCenter;

        // load all three pages into our scroll view
        [self loadPageWithId:9 onPage:0];
        [self loadPageWithId:0 onPage:1];
        [self loadPageWithId:1 onPage:2];

        [scrollView addSubview:pageOneDoc];
        [scrollView addSubview:pageTwoDoc];
        [scrollView addSubview:pageThreeDoc];

        // adjust content size for three pages of data and reposition to center page
        scrollView.contentSize = CGSizeMake(960, 416);
        [scrollView scrollRectToVisible:CGRectMake(320,0,320,416) animated:NO];
}

- (void)loadPageWithId:(int)index onPage:(int)page {
        // load data for page
        switch (page) {
                case 0:
                        pageOneDoc.text = [documentTitles objectAtIndex:index];
                        break;
                case 1:
                        pageTwoDoc.text = [documentTitles objectAtIndex:index];
                        break;
                case 2:
                        pageThreeDoc.text = [documentTitles objectAtIndex:index];
                        break;
        }
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)sender {
        // All data for the documents are stored in an array (documentTitles).
        // We keep track of the index that we are scrolling to so that we
        // know what data to load for each page.
        if(scrollView.contentOffset.x > scrollView.frame.size.width) {
                // We are moving forward. Load the current doc data on the first page.
                [self loadPageWithId:currIndex onPage:0];
                // Add one to the currentIndex or reset to 0 if we have reached the end.
                currIndex = (currIndex $gt;= [documentTitles count]-1) ? 0 : currIndex + 1;
                [self loadPageWithId:currIndex onPage:1];
                // Load content on the last page. This is either from the next item in the array
                // or the first if we have reached the end.
                nextIndex = (currIndex $gt;= [documentTitles count]-1) ? 0 : currIndex + 1;
                [self loadPageWithId:nextIndex onPage:2];
        }
        if(scrollView.contentOffset.x $lt; scrollView.frame.size.width) {
                // We are moving backward. Load the current doc data on the last page.
                [self loadPageWithId:currIndex onPage:2];
                // Subtract one from the currentIndex or go to the end if we have reached the beginning.
                currIndex = (currIndex == 0) ? [documentTitles count]-1 : currIndex - 1;
                [self loadPageWithId:currIndex onPage:1];
                // Load content on the first page. This is either from the prev item in the array
                // or the last if we have reached the beginning.
                prevIndex = (currIndex == 0) ? [documentTitles count]-1 : currIndex - 1;
                [self loadPageWithId:prevIndex onPage:0];
        }     

        // Reset offset back to middle page
        [scrollView scrollRectToVisible:CGRectMake(320,0,320,416) animated:NO];
}

Source Code: http://accella.net/dev/Labs/InfiniteScrollView/InfiniteScrollView.zip

The place to start is of course in the help section of GitHub. You will need to install Git, generate a keypair and set you username and email into Git. Look to the help section for step by step instructions. Once you have that setup, you’re ready to start working with Git.

$ cd myProject
$ git init

First, we have to setup our project directory to use Git. The code, ‘git init’, will do this for us. For my situation, I did not want to touch the master branch. I only wanted to work in a separate branch. I did not even want to fetch the files from the master repository.

$ git add .
$ git commit -m 'comment goes here'

This code will add all the files in the directory to be committed and then commit those files with a comment. This will add the files to the master branch. However, I don’t want to change anything on GitHub in the master branch. Not to worry though, we haven’t connected to the remote URL. So, at this point it is only committing locally. Now that everything is established locally, let’s look at our branches.

$ git branch

This will show you all the branches you have created, as well as list the branch you are working in with an asterisk. For now, it should only show ‘* master’. We are currently working in the ‘master’ branch. My instructions were to not touch the master branch. So, let’s create a new branch:

$ git branch newBranch

You have now created a new branch named, ‘newBranch’. If you now type ‘git branch’, it will list ‘master’ and ‘newBranch’. However, you’ll notice that ‘master’ still has the asterisk next to its name. We are still working in the ‘master’ branch. To switch to our new branch, use the ‘checkout’ command.

$ git checkout newBranch

Now we are working in the right spot when we commit our project. We are going to be committing our project to a remote location, so our next step is to define that location.

$ git remote add origin git@github.com:user/repository.git

This will add our remote location so when we commit our changes, it not only commits them locally, but also to the server. You can find the URL to use at the GitHub repository page. The word ‘origin’ is the name of the remote location that we are adding. So, in the above example, we are adding the remote location ‘git@github.com:user/repository.git’ and naming it ‘origin’. And now, the final magic command to get our project into GitHub:

$ git push origin newBranch

Remember, ‘origin’ is the name of our remote location that we have saved, and ‘newBranch’ is the name of the branch that we are creating/pushing to. The project is now on GitHub in a new branch that we created just for the project. If you have any tips or suggestions for achieving this task, please do share.

We have always pursued innovative projects because we want to drive breakthroughs in computer science that dramatically improve our users’ lives. Last year at Google I/O, when we launched our developer preview of Google Wave, a web app for real time communication and collaboration, it set a high bar for what was possible in a web browser. We showed character-by-character live typing, and the ability to drag-and-drop files from the desktop, even “playback” the history of changes—all within a browser. Developers in the audience stood and cheered. Some even their laptops.

We were equally jazzed about Google Wave internally, even though we weren’t quite sure how users would respond to this radically different kind of communication. The use cases we’ve seen show the power of this technology: sharing images and other media in real time; improving spell-checking by understanding not just an individual word, but also the context of each word; and enabling third-party developers to build new tools like consumer gadgets for travel, or robots to check code.

But despite these wins, and numerous loyal fans, Wave has not seen the user adoption we would have liked. We don’t plan to continue developing Wave as a standalone product, but we will maintain the site at least through the end of the year and extend the technology for use in other Google projects. The central parts of the code, as well as the protocols that have driven many of Wave’s innovations, like drag-and-drop and character-by-character live typing, are already available as open source, so customers and partners can continue the innovation we began. In addition, we will work on tools so that users can easily “liberate” their content from Wave.

Wave has taught us a lot, and we are proud of the team for the ways in which they have pushed the boundaries of computer science. We are excited about what they will develop next as we continue to create innovations with the potential to advance technology and the wider web.

// Returns a resized image
- (UIImage*)imageWithImage:(UIImage*)image scaledToSize:(CGSize)newSize {
        UIGraphicsBeginImageContext(newSize);

        [image drawInRect:CGRectMake(0,0,newSize.width,newSize.height)];
        UIImage* newImage = UIGraphicsGetImageFromCurrentImageContext();

        UIGraphicsEndImageContext();

        return newImage;
}
// Returns a masked image
- (UIImage*) maskImage:(UIImage *)image withMask:(UIImage *)maskImage {

        CGImageRef maskRef = maskImage.CGImage; 

        CGImageRef mask = CGImageMaskCreate(CGImageGetWidth(maskRef),
                                        CGImageGetHeight(maskRef),
                                        CGImageGetBitsPerComponent(maskRef),
                                        CGImageGetBitsPerPixel(maskRef),
                                        CGImageGetBytesPerRow(maskRef),
                                        CGImageGetDataProvider(maskRef), NULL, false);

        CGImageRef masked = CGImageCreateWithMask([image CGImage], mask);
        CGImageRelease(mask);
        UIImage* retImage= [UIImage imageWithCGImage:masked];
        CGImageRelease(masked);
        return retImage;
}

...
UIImage *image = [UIImage imageNamed:@"myImage.png"];
UIImage *mask = [UIImage imageNamed:@"mask.png"];
UIImage *resizedImage = [self imageWithImage:image scaledToSize:CGSizeMake(76,92)];
UIImage *maskedImage = [self maskImage:resizedImage withMask:mask];

Image masking from [iPhone developer:tips];

As stated in the introduction: “This book is for all iPhone and iPod touch developers who want to know more so that they can tackle more difficult programming tasks on their way to creating the next great app”. This book is not for developers who are just beginning iPhone development. As the introduction points out (and which I wholeheartedly agree with), for beginning iPhone development, check out ‘Beginning iPhone Development’ by Dave Mark and Jeff LaMarch. However, if you have a basic understanding of iPhone development and are ready to explore some more advanced concepts, then this is the book for you.

The developers in the book each touch on very different scenarios that you may face in development. These are: game timers and logic, peer-to-peer networking, multithreading, implementing multitouch, game development with cocos2d, streaming audio and finally developing with Core Location, XML, and SQLite. With such a wide range of topics, it’s likely that you won’t be working with everything that is covered in the book. On the other hand, that just means that this book will hold something for everyone.

One of the great things about this book is the authors strive to take these different advanced concepts, which some might find a little frightening to tackle on their own, and present them in a simplified way that invites the reader to continue challenging themselves to find a way to overcome the problems they face in development. For example, in chapter 3, Gary Bennett discusses multithreading. Though I have never worked with multithreading before, I found the chapter to be very informative and easy to grasp. Gary first helps you to understand what threading is. He then explains some pitfalls to avoid when threading. Finally, he includes some code for an app to show you how to implement it.

In addition to the easy explanation of key concepts, I found it quite refreshing to see the logic that other developers use to overcome the obstacles they face. As we all know, there may be many ways to approach any particular problem. The authors here explain the logic that they used when programming and why they did or did not approach the problem in that way. I find that getting a feel for the logical process that others use in development helps me think of problems from a different angle in my own work.

In conclusion, if you are an iPhone developer or are studying to become one, this book is a must read. It achieves its goal of helping its target audience to get into advanced development projects, it presents the information in a very clear way and above all, it’s packed with useful information that you will be able to use in your own projects.

THE PROBLEM

$to = $_POST['to_email'];
$subject = $_POST['subject'];
$message = $_POST['message'];
$headers = "From: ".$_POST['from_email'];
mail($to,$subject,$message,$headers);

This is pretty much what I had my contact form posting to. All I focused on was two things: all fields needed to be dynamic and the script needed to send mail somewhere. It got the job done, but there is absolutely no security measures in place. Anyone could set up an automated script to post to this page. Email header injection can allow the evil attacker free access to modify the email, change who it is sent to, send it to multiple people , change the content type and more. A line feed must be added for every header. Someone could then post the following:

victim1@email.com%0ABcc:victim2@email.com

Using this and similar methods, the user has full control over our email script.

THE SOLUTION

First of all, you’ll notice that I’m not checking any data that is coming into my script. This security measure should always be in place. Therefore, each incoming piece of data should be sanitized and validated. Also, it’s good to make sure we have the latest release of PHP installed on our server. Newer versions of PHP will have improved security measures for email header injections.

Another added security measure that we can add is a token. A token is a random string generated and passed through the form, and stored in a session or cookie. Our mailing script can then verify that the users saved token matches what was passed to it. This way, we make sure that the mail is being submitted through our form, and not some external script. With these security measures in mind, let’s strengthen the security of our mailing script.

/********* form.php *********/

// create a token

session_start();

$token = md5(uniqid(rand(), TRUE));

$_SESSION[‘token’] = $token;

// insert token into a hidden input inside the form
input name="token" type="hidden" value=" $token; "

/********* form_submit_here.php *********/

session_start();

function check_token($token){

return($token == $_SESSION[‘token’]) ? true : false;

}

function check_string($string_to_test){

$bad_words = array(“cc”, ”to”, ”bcc”, ”Content-Transfer-Encoding”, ”content-type”, ”mime-version”, ”multipart/mixed”, ”%0A”, ”%0D”, ”\r”, ”\n”);

foreach($bad_words as $bad_word){

if(stripos($string_to_test, $bad_word) !== false){

exit; // injection attack detected

}

}

return $string_to_test; // no injection attack detected, string is safe to use.

}

if(!check_token($_POST[‘token’])){

exit; // token doesn’t match, post came from outside our form.

}

$to = check_string($_POST[‘to_email’]);

$subject = check_string($_POST[‘subject’]);

$message = check_string($_POST[‘message’]);

$headers = “From: “.check_string($_POST[‘from_email’]);

// token is valid and all our dynamic variables check out ok. Send the email.

mail($to,$subject,$message,$headers);

Of course, there is much here that you may wish to alter such as better error handling, error logging, etc. By spending just a few extra minutes of typing, we have greatly strengthened the scripts security measures. Whatever variation of this script that you may use, make sure you validate input when working with dynamic variables.