Are you Still Manually Approving Online Sales? Don’t!

The whole point of the online sales revolution, and as a direct result, the growth of companies like Amazon, eBay, and dozens of smaller sites like Newegg and ZipZoomFly, is to take advantage of the benefits brought by technology to the retail industry. These advantages include less overhead costs, fewer employees, constant availability, and instantaneous sales. So, please do tell, why is that you’re still manually verifying and validating all sales before they go out!?

This may not be too obvious when you’re selling tangible goods over the internet – after all, there is still a lot of the “human element” when it comes to packaging and shipping the product. But when you’re selling digital products, be it software, music, games, or text, you should never, ever have a human doing the verification. It’s insulting.

With presence of automated purchase validation systems, like 2Checkout and PayPal IPN available which give virtually real-time updates on the status of a transaction and let you know when you’ve received your money (or at least when it’s on its way), there is absolutely no need for a data monkey to press “OK” at the prompt. After all, what’s this data monkey know that PayPal’s IPN report hasn’t already told your system?

Continue reading

Proper Shell Scripting on Windows Servers with Perl

  • Fact: Shell scripting is a must for any serious IT admin managing a server. From automating backups to checking logs and keeping server performance and load in check, scripting is a must.
  • Fact: Shell scripting on Windows sucks.1
  • Fact: Shell scripting on Linux and other *nix operating systems is powerful, well-documented, and quite straight-forward.

Most people take a look at these three facts, and instantly come to a conclusion.. the wrong conclusion: you can’t properly manage a Windows server because it’s inherently lacking in the shell scripting department.

Continue reading


  1. Hopefully Monad (Microsoft Power Shell) will provide a solution, but so far the results are mixed; and it’s not popular enough to be considered a viable substitute at the moment. 

Complete .NET Portability with Wine & Mono?

Mono is the open-source version of Microsoft’s .NET Framework. It implements most of the backend framework features, but unfortunately, falls flat on its pretty little face when attempting to display the user interface – which is what desktop apps are all about.

Wine on the other-hand, is a Linux port of (major parts of) Microsoft’s Win32 library – the core dependencies of the Windows development libraries, and more importantly, the win32 interface elements. With Wine, you can run many traditional C++ win32 executables on Linux, with certain limitations.

Mono’s biggest stumbling block is the GUI and .NET programs that use P/Invoke to call native non-managed win32 dlls – Mono is a pure .NET environment, and can’t handle them. But from the description above, that’s exactly what WINE excel at… So can’t we use WINE + Mono to make just about any .NET program run on Linux fresh out of the .NET compiler?

Unfortunately, the answer is no. Back when the Mono project was first starting out, the Mono development team considered using WINE to implement the System.Windows.Forms namespace of the .NET Framework (which is practically 100% native C++ unmanaged win32 code in .NET wrappers). But they made the right choice in deciding to not take the easy way and go that route, leaving the integrity of the Mono project intact and focusing on true cross-platform user interface libraries instead (the GTK# is now the UI Library of choice for cross-platform .NET applications).

Continue reading

Managed Pointers to Managed Objects (or Aliases for Objects) in C# and Visual Basic .NET

One of the biggest advantages of managed frameworks/platforms like Microsoft’s .NET Framework (and it’s Linux-counterpart, Mono), and Java is that you, as a developer, have a choice of not mucking around with pointers. To be totally honest, with Java you’re forced not to – in C#, it’s a choice you have to make.

There’s plenty of good reasons for not using (unsafe!!) pointers, but that’s not the issue here. The question is, what if you want something to “point” to another object, and synchronize it’s value automatically, without resorting to unsafe pointers? There’s actually a quite simple answer using just a single line of C# code.

Whereas in C++ you could write something like what appears below, in C# you’d have to declare it as unsafe, then jump through a hundred hoops to get it to properly point to a managed object:

Continue reading

Apple’s New Animation Framework

Although we try our best to be impartial when it comes down to OS wars, and we have, throughout the years, presented the pros and cons of Windows, Linux, and other operating systems, you’ve probably noticed that NeoSmart Technologies isn’t too big on Apple. Well, color us purple, but this we have to talk about.

Apple [[AAPL]] has a new technology due to ship in Leopard that is pretty damn impressive to hear some of the developers (or at least those at liberty to discuss what they’ve been told) talk about it. According to this Wired News article, this framework will focus on making it easy for developers to add Next (Delicious) Generation graphics to their applications, bringing the concept of UI to a whole new playing field.

While it sounds just plain awesome, we can’t help but look at it with mixed feelings. Since this is Apple and not Microsoft we’re talking about, we’re pretty darn sure everything they say can and will be found in the RTM release of OS X Leopard *cough* WinFS *cough*, but whether or not it will revolutionize the concept of user interfaces everywhere remains to be seen.

Granted, the effects are supposed to be astounding. But that’s not the question, next-gen UIs (hereby dubbed “Desktop 2.0”) are almost always a matter of how and not what. As the Wired article states, these same “amazing” graphical innovations with the UI do already exist in certain programs (like Disco, the CD burning utility for OS X), the only difference is, Apple promises to make it much easier to get the same end results.

Continue reading

{smartassembly} reviewed


Programs. They start off in the IDE as nothing more than a blank page, then (with the blood, sweat, and toil of programmers and many sleepless nights) they turn into volumes of monospaced text, a standing testament to the dedication of programmers and the way they work. Then from the myriads of the source code and the magic of the compiler comes the executable file, the fruit of all the efforts. No one really sees the actual work that went into it: all they see is a file that runs and a program that works.

Well, that’s the way it’s supposed to go. But with Java and .NET, it doesn’t really work that way. These frameworks/virtual-machines rely on the concept of virtual machines, compiling to Byte Code (Java) or MSIL (.NET). What looks like an executable file is actually source code being passed on to the framework for translation and execution. So your source code is never safe, and it’s never really compiled.

We’ve been using .NET for our programs at NeoSmart Technologies for years now, and we’ve never really come across this as a problem, simply because our software’s always been and always will be freeware. However, in recent months we’ve seen some of our more popular programs like EasyBCD being decompiled and its source-code stolen left and right by those that don’t know any better. So we set off looking for the best obfuscation tool for the job, and found much more than what we were looking for.

Continue reading

Please Microsoft, Stop Holding .NET Back!

As dedicated developers, end-users, and champions of Microsoft’s .NET Framework, we’re making a final plea to Microsoft and the .NET Framework team to save .NET and make it a real multi-platform framework. Please!

Sun could (and did) do it with Java, so why can’t Microsoft just swallow the pill already and provide real support for the .NET Framework on all operating systems? Yes, that includes Linux and Mac too. It’s ironic, because the .NET Framework has so much potential as a platform with its unique multi-language structure, nifty features, excellent libraries, (relatively) well-performing output, and darn-good innovative technologies like LINQ coming-up and XAML already here. Yet Microsoft just doesn’t realize that if they truly want .NET to succeed, they’ll have to bite the bullet and stop pretending that only officially supporting Windows won’t make users leave Linux/Mac/BSD/Whatever and buy licenses for Windows instead.

Continue reading