Source: tech.co

Most of the information that I’m presenting here is just from the simple introductory Ruby on Rails tutorial.  I’d encourage you to follow that official introduction should your interest be piqued, this is only an introduction from a developer who is still learning about the framework (i.e. there are likely to be inaccuracies peppered throughout).

RVM

The first thing we want to do is install the Ruby EnVironment Manager (RVM).  The RVM is just a bash script that wraps around some curl and git commands.  This allows us to have independent ruby binaries for distinct applications (you might have one per project), and the binaries may have their own associated gemset (Ruby libraries).  There is a similar utility in Python called virtualenv (though I have to say the virtualenv seems to be superior).

We use the RVM to install a Ruby binary (we can give it a name to identify it with some function) 

rvm install ruby-newtonsit

rvm use ruby-newtonsit

There are various implementations of the Ruby language; when we perform an installation as detailed above we are installing Ruby MRI (Matz’s Ruby Interpreter, named after the creator of Ruby Yukihiro Matsumoto); this is the mainstream C implementation of Ruby.  Another implementation that I have experimented with is JRuby (written in Java).  We can run our Ruby on Rails instance using JRuby, which some say has better performance under certain instances (the reasons get into threading and the like; I’ve not really fully investigated it).  JRuby also lets us use the ‘java’ module, which more or less allows us to access and use Java (including any Java classes we might define) inside of Ruby.  It’s quite incredible!

I’m touching on this mostly because it is interesting, but I would also mention that when we install the “rails” gem using JRuby and then create a Rails project, Rails takes account automatically of the slightly different dependencies of JRuby (as compared to MRI Ruby).

Creating a Project

We can now proceed to create a Rails project. There are all kinds of command line flags available (most of which I haven’t explored), but in the simplest instance we enter a command like so:

rails new newtonsit

This creates a project directory populated by the standard Rails folder structure and files, and installs required dependencies.  Here we observe one of the core characteristics of Rails.  The Rails documentation notes that Rails is “opinionated” when it comes to web development.  What this means is that Rails sets up what its developers feel to be the optimal environment for web development. The folder structure, the location of files, everything is tailored specifically by Rails’ developers to follow what they have agreed to be ideal.  Therefore we more or less stick with it.  This is a feature of Rails.  Apparently it is possible to deviate from this structure and move things around in unorthodox ways, but this is against the Rails way of doing things.  By having this “opinionated” view on how to do things, a lot of potential complexity in configuration is done away with.

Utilities

We can now cd into the new project directory.  Inside the “bin”folder we have a few different useful binaries.  We have bundle (I believe this is a wrapper around Ruby’s gem) which parses the Gemfile at the root of the project and uses it to install dependencies.  Any time we alter the Gemfile we can call ./bin/bundle to install new packages; there are intricacies to Bundler (its full name), but I’ve not delved into them.  We also have rake (Ruby’s make) which is used to perform various tasks; you’ll most often be using it to perform database functions (“migrations”).  We can actually specify the exact Ruby binary we wish to use in our project inside the Gemfile, and RVM is intelligent enough to select the binary we specify:

ruby ‘2.2.1’

(To be honest, I have not fully ironed out the kinks in this system; this is what led me to say I prefer Python’s virtualenv)

Scaffolds

Let’s create a blog (this seems to be the Canonical Method for introducing web frameworks).

rails generate scaffold Post title:string body:text published:boolean user:references

This will set up a Post model for us; most of what is going on is clear here, save except for the last clause: user:references.  This is where we declare a relationship between the User model (which we are yet to establish) and the Post model.  We are establishing the foreign key so that users may have many posts.  Let’s now set up the User model.

rails g scaffold User name:string:uniq password:digest

Note that we can use “g” as a shorthand for “generate” in the above statement.  We use rails generate foo to generate all kinds of things, from scaffolds to model to controllers.  We then go into our User model file and declare the many-to-one relationship between posts and users; this can be done at any stage.  We want something like the following:

class User < ActiveRecord::Base

  has_many :posts, :dependent => :destroy

  has_secure_password

  validates_uniqueness_of :username

  def to_s

        “<User ##{self.id}: #{self.name}>”

  end

end

Note also that we need to go into the Gemfile for the project and uncomment the ‘bcrypt’ gem so it can be used in hashing passwords for storage in the database.  Notice that the uniqueness of usernames is being enforced at the code level and the database level.  For large applications with many concurrent database connections this can introduce race condition issues… another thing I’ve only really heard mention of and not delved into.

Migrations

We have generated controllers and Ruby models, but we have not in fact done anything yet with the database.  We have generated migration files, present in ‘db/migrate’.  We can go ahead and edit these to our heart’s content; they’re just Ruby scripts.

We perform the migration (modifying the database) by calling ./bin/rake db:migrate.  By default Rails is set up to interact with a SQLite3 database for development purposes.  The database interaction is abstracted away via Active Records (what amounts to Rails’ ORM).

We can also use the ‘db/seeds.rb’ file to “seed” the database with data.  This is useful if we wish to quickly reset the database to some default state.

config/routes.rb

‘config/routes.rb’ defines the routing for the application.  If we take a look now we can see that we have Users and Posts declared as resources.  This will mean that interactions with User and Post objects adhere to the Representational State Transfer (REST) web standard for interacting with information on a server.  Rails uses those funny obscure HTTP methods such as DELETE, PATCH, PUT, etc. in a natural way to help us with managing our objects. We also use the ‘root’ method in ‘config/routes.rb’ to declare the root action of the application.

We can use rails s (shorthand for rails server) to quickly run the rails built in development server, then point a browser at the address specified in little server startup message to see the fruits of our labour.  If you put in a silly non-existent route you can get a nice page displaying all the routes available in the application and the various associated route names and HTTP methods.

Further

There is much more to be said; it is best to go through the extremely informative introductory tutorials available on the Ruby on Rails website.  The only things that I have done here that are not present there are using the rails generate scaffold command (the tutorial takes you through manually creating controllers, models, etc.) and using the RVM.

Inside the view files you use Ruby to interact with models passed to the view in a similar fashion to PhpRenderer objects in the Zend Framework 2.  I was able to easily roll my own multi-user login system with a few simple lines of code, and I’m yet to even really properly delve into the gems that are available to help with standard web development activities (like Composer packages in PHP). I know that rake provides all kinds of cool features and allows you to define custom activities that will perform more or less whatever action you wish to help you in development, in much the same fashion as the traditional make utility.  You can generate documentation, track “TODOs” and the like in comments throughout your code, reverse database migrations, and a whole bunch of other things.

The next things I will probably be looking at is the automatically generated unit testing scaffold and Apache integration.  It is my understanding that there is an Apache module for Ruby.

Conclusion

Ruby on Rails is known for the incredible pace with which it allows developers to implement the core functionalities of a web application. By doing away with unnecessarily obscure configuration and using powerful yet simple command line utilities, as well as by using the famously well designed and throughly object oriented language of Ruby, Ruby on Rails has become somewhat of a darling for progressive web developers.  If nothing else it is great fun!

The post Tom’s Fifteen Minute Ruby on Rails appeared first on NewtonsIT - Cutting edge cloud software developers.

Flat Design

Flat design is the current go-to in user interface design. Flat design is in a way a rebellion against the skeuomorphism paradigm, where what you see on screen is deliberately designed to in some way imitate a ‘real world’ object. For example, for a guitar-tuning app a designer who favours skeuomorphism might have a little needle bobbing back and forth on screen to indicate the tuning, in a similar way to how the old style analogue guitar tuners are designed.

An example of skeuomorphism. Source: bluegrasstoday.com

Flat design eschews such an approach in favour of using the digital display as its own entity, distinct from analogue interfaces. Flat design plays to the strengths of the digital format, organising information in uniquely digital ways and ditching the verisimilitude of skeuomorphism. The simplified design has added benefits, increasing the performance of software that needs to display content (e.g. websites) and most importantly facilitating responsiveness.  This is what makes the transition from a desktop display to, say, a mobile display, seamless.

An example of flat design. Source: designskilz.com

The Next Step?

In characteristic Google style, Google has already opted for their own re-imagining of flat design to… semi-flat design. They call it material design, and at NewtonsIT we are big fans. Where flat design might recommend eliminating all shadowing effects, material design uses the somewhat skeuomorphic approach of shadowing to indicate items that a user might interact with, like buttons or sliders. This mid-ground between skeuomorphism and flat design represents a good, functional compromise and progress towards the next innovation in design principles.

The post Hooray! Rich UI Design! appeared first on NewtonsIT - Cutting edge cloud software developers.

Definitions

Technical debt: If you don’t put in upfront effort, for example in planning out the structure of a codebase, later down the track you are more than likely doing to have to perform a painful overhaul.  You have accrued technical debt and would have been better off putting in the upfront effort, because now the task you face is drastically more challenging and potentially overwhelming.
Atomic commit: Committing a small, self-contained change to the code, rather than a larger change that might for example represent an entirely new feature.

Build lights, a quick visual indication of the build status as determined by the build server.
Source: Dushan Hanuska – http://www.flickr.com/photos/hanuska/5931613961/in/photostream/

The Idea

The fundamental precept of CI is that developers working on a shared codebase integrate their development efforts continuously into the mainline of the code repository. Rather than working on code for days or weeks and then making a large commit for some new feature, developers make a conscious effort to commit more atomically.

Beyond this core idea comes the two main helpers in the continuous integration cause: test driven development/test suites and build servers. The test suite written as the software is developed is used by a build server to ensure the integrity of the code as developers make their continual integrations into the mainline codebase. The build server then builds the software, generating the latest bleeding-edge build and any documentation written in the code (think javadoc or pydoc) and useful indicators of the code quality.

The continuous nature of CI means that developers know more-or-less immediately if their contributions are breaking the build. Any scope for build-breaking code to be committed and then accrue technical debt is eliminated. Ideally this will eliminate the Integration Hell that is the bane of software projects. With the builds automatically tested and approved by build servers CI goes hand-in-hand with continuous deployment, where bleeding edge builds can be released rapidly to users for them to enjoy the benefits of the latest features as soon as possible.

Build server software: Buildbot

Buildbot, the “continuous integration framework” written in Python is just one of many build servers. With Buildbot trained on your code repository, testing, building, deploying and notifying can all be automated. As I said only a few days ago, such automations can astronomically improve productivity and serve to remove the lumbering human from the loop.

Newtons IT are always looking for new ways to broaden our methodology horizons; CI is the next thing we want to check out. Leave your comments in the comment section, let us know what you think of continuous integration!

Sources:

[1] http://www.thoughtworks.com/continuous-integration

[2] https://en.wikipedia.org/wiki/Continuous_integration

The post Continuous Integration appeared first on NewtonsIT - Cutting edge cloud software developers.

Poor UI Design. Source: http://weblogs.asp.net/alex_papadimoulis/146784

Particularly for older users, unintuitive user interfaces or sudden changes from established norms can have a devastating effect. Users will often simply give up in frustration; for elderly users this can mean a withdrawal back into isolation as they are unable to use web-mail or social media accounts. For businesses, this means that the ‘older’ demographic gets entirely removed from the potential customer base.

Low contrast interfaces, hidden interfaces and buttons requiring supernatural dexterity were identified as the bane of older users. It wouldn’t be too far of a stretch to also say that there is much cross-over between “older” users and those that identify as “non-computer people”. Web designers need to pay careful consideration to the needs of such people, not just those up-to-date on the latest bleeding edge web interface trends.

Lauren suggests that a solution to this problem might be the provision of simplified versions of websites. This would go far in remedying the issues that “non-computer people” and older users face. Good design coupled perhaps with a simplified option will attract and retain a large demographic of customers, resulting in boosted business and happier customers.

Newtons IT pay keen attention to the needs of everyday users, so that tasks can be accomplished using clean, intuitive interfaces. Nobody wants to use a bloated and poorly designed website; now is the time to ditch your tired old confusing site and opt for a carefully thought out and designed web solution, courtesy of Newtons IT.

The post Danger! Poor UI Design! appeared first on NewtonsIT - Cutting edge cloud software developers.

It’s exactly areas such as these that you need to start thinking about automation.

Automation… perhaps things could be made more efficient though.

Top IT executives were recently asked about areas they consider ripe for automation. For your everyday business, the main focus should be on removing the human from the loop on the manual processes; as one IT exec. said,

I want the least number of people touching things so they can focus on their jobs and driving value for the company.

In particular data archiving and analytics are areas where the computer can and should do it all for you. You shouldn’t even have to think about backups of your mission critical data. Newtons IT staff are experts when it comes to setting up automated backup routines, giving you peace of mind in knowing that you’ll never be subjected to the devastation of mass data loss.

Analytics is also an area where computers frankly do it better. Computers can record data for you (sales data, website access data, any kind of data you can think of) and crunch it all for you to spit out useful indicators of your business success or areas you need to work on.

An investment in automation will pay off almost immediately, slashing labour costs and boosting productivity. Engaging Newtons IT in automating processes in the right way is an investment you can’t afford not to make as we move into the Big Data age.

The post Automation appeared first on NewtonsIT - Cutting edge cloud software developers.

Source: techopti.com

Windows 10 is coming, and with it Microsoft’s latest efforts in a modern web browser: Microsoft Edge. For a while now Microsoft’s offerings on the browser front have been somewhat lack-lustre and unfashionable. There was a time when Internet Explorer ruled the browser world, battering out the likes of Netscape Navigator. From the ashes of Netscape Navigator came Mozilla Phoenix, later renamed to Firefox, and thus began the decline of Internet Explorer. Nowadays, there are browsers galore and the battle still rages: Internet Explorer, Firefox, Chrome, Opera, Safari… the list goes on.  Chrome has swept the world with its lightweight offerings and integration with the Google ecosystem (it is made by Google, after all), and the once all powerful Firefox is more slow and bloated with every release.

Microsoft is hoping to regain dominance with its brand new Microsoft Edge, making a break from the Internet Explorer line to build a modern web browser deeply integrated with its new Windows 10 operating system. Microsoft has emphasised its built in support for social use of the world wide web; for example, a new feature called ‘inking’ will allow users to mark up pages as they like and send the page with the mark-ups they have made to friends.

Edge is still evolving and we are yet to see how it will look in the end, but at Newtons IT we are certainly looking forward to trying out the new features it will offer us as developers. More than anything else we look forward to using Microsoft Edge’s new features to wow our clients and give them an Edge over their competitors in web presentation and presence.  Get in contact with Newtons IT to see how we can use the next generation of browsers to boost your business today!

The post Microsoft Edge appeared first on NewtonsIT - Cutting edge cloud software developers.

Newtons IT is serious about staying abreast of new technologies and exposing ourselves to different development methods and paradigms.  Already I have written about Agile, about Zend Framework 2 and about Flask. Django is the next in line, but at this stage this developer has not even developed a simple “Hello World!”-type website using Django.

So, from the outside looking in, what is there to be said about Django and what recommends it to me as the next thing to check out?

The Python Dictatorship

Guido Van Rossum, Python’s author, is known as the “Benevolent Dictator for Life” in Python circles. As a reference to this, Jacob Kaplan-Moss (co-creator of Django) called himself the Co-Benevolent Dictator for Life of Django. He has spoken of its explosive growth, from its infancy in a fast-moving newsroom to its current application in… any web application you could think of! “Scripting languages”, perhaps previously looked upon as only for small applications and prototyping, are now taking their place beside the old guard of Java and .NET.

Kaplan-Moss, as one of the co-benevolent dictators, and with a degree in literature (the other has a degree in journalism) has made a point of ensuring Django has documentation of the highest quality. This is a point that cannot be understated. The quality of documentation is often a proxy for the quality of the software itself. Well thought out and logical documentation is often indicative of well thought out and logical software.

For this developer, perhaps even more so than the simple fact of the meteoric and exponential growth in Django usage, the superlative documentation has convinced me to dive in and check it out. You should too!

The post Django appeared first on NewtonsIT - Cutting edge cloud software developers.

GitHub Atom

It is clear that Atom took a lot of inspiration from Sublime. In this blogger’s opinion the two most crucial differences are that Atom is web-based (built on top of Google’s open source Chromium browser), and has the backing of GitHub, a company that (at present) can do no wrong. Atom has gone through extensive beta testing and is fully free and extensible, so why not download it now and give it a whirl?

Lightweight text-editors such as Atom allow a developer to easily and rapidly navigate between project files in all kinds of different languages, with lovely syntax highlighting and other helpful features. Even amongst Newtons IT staff there is controversy regarding the ‘best’ text editor, but all agree that GitHub Atom is worth a try. Check it out now!

The post Happy 1.0 GitHub Atom! appeared first on NewtonsIT - Cutting edge cloud software developers.

If your website is not optimised for Google’s search algorithms, you are virtually consigned to the oblivion that is… the second page of results!  When is the last time you went to the bottom of the Google search results page and clicked the next button?  How about the last time you skipped over to page eleven of the search results?

It’s definitely worth spending some time thinking about how your website ranks in Google’s search results, and on April 21 this year things changed dramatically.

Mobilegeddon

On April 21, Google upended the way it ranks mobile searches.  When the Googlebot crawls through and assesses your website now, it will determine how mobile-friendly your website is and this will contribute towards page ranking.  If your website is not responsive or does not have a mobile version, your page ranking is going to take a hit.  If your website it lovely and mobile-friendly, you’re going to see a nice uptick in your page ranking.  Now more than ever before it is important that you make the move to make your site more mobile-friendly.

Google’s decision to change the page ranking algorithm is based on current trends.  Many people are doing the bulk of their web browsing using mobile devices these days.  Emailing, reading the news, buying products, banking… all of these activities and more are now done using mobile devices.  This means that the user experience on mobile devices has become far more important.  Should the user experience on mobile devices for your website be suboptimal, your page ranking will now reflect this.

What can I do?

Talk to Newtons IT about creating a responsive website.  The Google decision has been somewhat controversial, but in the end the central thesis is that user experience is king.  Google wants to see people using mobile devices presented with something that is pleasant to use on a mobile; this is in everyone’s interest, and a pleasant, responsive website means happy customers and better business!

For an FAQ from Google on the change, check out:

http://googlewebmastercentral.blogspot.com.au/2015/04/faqs-april-21st-mobile-friendly.html

The post Mobilegeddon? Not really. appeared first on NewtonsIT - Cutting edge cloud software developers.

I have personal experience in dealing with projects inherited from third parties that required testing and did not come with a skerrick of test code.  At times like this I have been forced to make a decision: do I try to implement test code, or do I jump in and test things by hand?  Yes, ideally we will end up with a nice set of test code that can be run with the click of a button any time we make a change, but with deadlines looming someone has to roll up their sleeves and start testing manually.

Code being tested can often times be unfamiliar, using technology foreign to the tester or being poorly structured.  Through the testing process a tester is able to tease apart the code, understanding it better and refactoring it.  In the process an automated test framework can slowly be written.

But when things need to be tested now, here is what has worked in the past:

Damage Control

Fire up your favourite text editor and make a table with the following columns:

| If | Then | Actual | Notes | Status |

• If: These are the actions that we will perform.  Some examples might be if I click on the arrow or if I receive an email.
• Then: These are the results that we want to see when the if is performed.  For example, to accompany “if I click on the arrow” we might have “then I will be presented with a dropdown menu.”
• Actual: These are the results of performing the if.  This is what actually happened, and if it differs from the then that we pre-wrote we have a failing test case.
• Notes: Any additional notes.  If, for example, we do not get the expected outcome when we perform the if but we get something close to it, we might make a note to check with the client if the behaviour is acceptable.
• Status: A one or two word descriptor for the state of the test case.  For example, “failing”, “passing”, “on hold”, “indeterminate”, etc.

It is also a good idea to separate out the test cases in a logical fashion; we might have a group of test cases that address a certain module of a program, accompanied by some prose about what the module ought to be doing overall.

The test cases need to be gone through as often as possible.  This can take a fair amount of time, but sometimes this is unavoidable in the face of looming deadlines.  If time permits we will be refactoring and writing test cases as we become more familiar with the code, but under these damage control conditions we always look to provide the greatest value to the client that we can in the time we have.

Having said all this, please don’t put testers in a position where this has to be done.  A well written automated test framework will outperform a lumbering human every time, and driving development through testing will produce higher quality code that can be maintained into the future.

The post Testing Manually appeared first on NewtonsIT - Cutting edge cloud software developers.