Over the past fifteen years, Linux has built its brand around security and flexibility. The open source community and many technology aficionados berate Windows for its security flaws, and hail Linux and Apple as the platforms for serious, reliable computing. Few serious studies have rigorously compared the platforms in the wild, and those that do are often accused of bias. Temporarily setting aside the prejudice that most have regarding the issue, could it be possible that in certain instances, Windows Servers are indeed more secure than Linux?
Continue reading
Monthly Archives: October 2014
Implementing Object-level Inheritance in Node.js
Prototype-based classes in JavaScript and Node.js bring a high level of flexibility to the software architecture. Since objects and classes are fully editable at any point in program operation, the functionality can be extended to implement object-level inheritance at runtime.
Continue reading
C# Design Patterns: #6 – Adapter
The Adapter pattern helps provide a better way to leverage existing code. Instead of requiring the developer to redesign components from scratch, the Adapter can integrate work from previous projects or other libraries.
Continue reading
Creating Custom UDL User Defined Languages in Notepad++
The Notepad++ editor is the Swiss Army knife of text editing. With hundreds of plugins, the tool can be configured as an editor to almost any development workflow. In the previous post, we reviewed how to add comments to a JSON configuration file. We will now create a custom editor that supports those comments and the custom configuration keywords.
Continue reading
Node.js – Adding comments to JSON files
Due to its tight coupling and interoperability with JavaScript, JSON has become the standard data transfer format for most JavaScript and Node.js applications. As opposed to its primary competitor format XML, JSON is much more compact and efficient for data transfer, and has a direct one-to-one mapping with the memory structures in the code. What JSON doesn’t enable, however, are comments in the JSON files.
Continue reading
Node.js – Passing Arrays in the Querystring
One of the enticing attributes of Node.js development is the high level of flexibility offered by the language. Whereas other web application frameworks often have more stringent and developed patterns for development tasks, Node is more of a Wild West, where the recommended implementation can be anyone’s game. One of those open-ended tasks is passing arrays through the Querystring.
Continue reading
PHP, Be Not Proud
Over the years, PHP has been instrumental to progress in the field of web development. As one of the early pioneers of server-side web scripting, the PHP language grew to become the dominant programming language of open-source web applications. Its free and open-source codebase made it the default programming language on Apache and Linux, and the large number of excellent web applications built on PHP will secure its existence for at least the next fifteen years.
Continue reading
Node.js – Dynamically Loading EJS Templates
Node.js offers a powerful engine for high-performance web development. One of the challenges with the stock Express distribution, however, is it’s low-quality default templating system. Jade is littered with obscure syntax, and often requires manual conversion from HTML templates in many development workflows. Luckily, installing the EJS templating system is relatively easy, and developers can reap dividends in increased productivity throughout the lifecycle of the software.
Continue reading
Clearing all SVN folders in Windows or Linux
Subversion, despite its many competitors with more modern distributed version control technology, is still going strong today due to its robust architecture and large user base. Although more modern subversion instances use only one “.svn” folder in the root of the checked-out repository, older versions may have a separate “.svn” folder in each individual subfolder in the project.
Continue reading
The Importance of Wireframing in Software Development
At each stage of software development, from design, to development, to deployment, there is opportunity for either keeping the status quo, falling behind, or achieving glory. Wireframing plays a crucial role in helping software projects achieve glory, as opposed to simply meeting goals.
First, a quick overview on the nature of wireframing. Similar to CAD drawings or blueprints, wireframes of a software project provide a skeleton outline of how key elements of the system will be laid out on the screen. The wireframing stage generally does not consist of finalized, high-end graphics or pixel-perfect positioning, but is rather focused on the general position of fields, elements, and user interface buttons.
Wireframes can be drawn on paper, however it is more effective to use a software tool such as Balsamiq, Axure, or Visio for the drawings. These design tools can make it easy to implement changes, duplicate repetitive content, and handle versioning. Balsamiq has achieved its own special standing among UI development tools with its quick rise to fame and popularity. Instead of depicting clean lines and elegant results, Balsamiq makes the entire drawing look especially “sketchy”, so that project stakeholders have no illusion that they are looking at a final product. Instead, Balsamiq produces wireframes more akin to something that would be sketched on a whiteboard, as opposed to an elegant CAD drawing. This lets viewers focus on the layout and general concept, instead of on the design elements that may be subject to future change. Regardless of the wireframing software, the end result will be a set of documents that provide a high-level view of the user interface and software functionality.
The key benefit of wireframing is how it provides a bridge between concept and creation. Before wireframing, the software is a fuzzy amalgamation of database entities and software architecture components. Once the wireframes are created, the software takes shape. Similar to sculpting, that first set of blows to “rough out” the software design are often the most critical. Not only do they define the final form of the application, they also provide the opportunity to implement creative ideas or enhancements. While the system is still in the wireframing stage, interesting concepts or UI paradigms can be added relatively easily. Once the system has progressed from wireframing into development, the UI is generally fixed and requires significant rework for any enhancements.
With all the benefits of wireframing, it can still be a challenging task to execute. Out of all the development tasks, wireframing takes the most creativity and inertia. Hewing the system out of rough stone, the architect or UI designer needs to bring everything together: the database, design, layout, and programming workflow. For sizable systems, this is the task that separates the master from the apprentice, and brings the software to life.