Release 1.0 Enables Software Start-ups to Rapidly Scale Agile Engineering Capacity

Responding to a growing supply challenge for talented software engineers in North American, Avantica Technologies introduced Release 1.0 for start-ups. The service targets Web application and software start-ups eager to quickly scale development and testing but, due to a chronic shortage of experienced software engineers, are unable to.

In Silicon Valley alone according to the U.S. National Venture Capital Association, 40% of the 130,000 open positions in 2011 were for software engineers, mainly in the social media, mobile and cloud computing technology sectors. Avantica is convinced its Release 1.0 service for start-ups will help more technology companies successfully get to market. Or, expand their existing market presence.

Bill Sutherland, Chief Engineering Officer at ArmedZilla.com found Release 1.0 helped fill the social networking platform’s need for talented software developers and testers who could quickly integrate into the company’s internal engineering team.

Sutherland explained: “The Avantica Technologies engineers were productive immediately, helping us meet our aggressive release goals.”

What is Release 1.0?
It’s a suite of integrated software engineering services designed to enable start-ups to rapidly build, launch or expand existing software apps. It supports scaling a engineering team within days, not months or quarters. The Release 1.0 framework consists of:

People:
Software Developers and QA engineers
Scrum Masters / Project Managers
CTO / VP Engineering
Talented, economical and available
Avantica Technologies customers choose the skill-set needed to integrate into their internal engineering team

Process:
Distributed Agile expertise, highly collaborative
Integrated extension of the start-up’s core team
Software engineering specialization, not IT services

Place:
Nearshore – Avantica’s software engineering centers are in Costa Rica and Peru
U.S. corporation, headquartered in Silicon Valley
Same U.S. time-zone, same English language

Price:
Avantica Technologies charges a fixed monthly rate per software engineer
Customers gain a dedicated team at a predictable cost

Release 1.0 Service for start-ups solves two addressable markets: one is the rapidly growing, venture funded start-up that needs to quickly release new features and integrations supporting its Consumer Web, eCommerce or Mobile app. offering. The second is the Angel or self-funded start-up looking to finish a POC or initial production software launch and needs to scale up a small engineering team. The service creates a path for small businesses to continue to do what they do well: create U.S. jobs. Forbes Magazine reported that small businesses created 55,000 new jobs in September, 2011. And, for the past two years, overall small business employment has been growing. Since November 2009, businesses with fewer than 20 workers added 735,000 new employees. Release 1.0 is designed to help that growth continue.

Rails Technologies Decisions

Let’s say you are working on a Rails project and you need to use a new GEM, or rather, you need a new area of functionality and you are pretty sure a GEM exists to solve your problem.  How do you go about deciding your approach?  Recently, I have found a pattern that works really well for this.  It’s a simple 4 step approach.  Let me take you through my approach using an example.  I have a new project and need to add authentication.  I have been using restful_authentication for years, but since I am now on Rails 3 I decide to re-examine the landscape.

Step 1 – ruby-toolbox.com

First, I go to ruby-toolbox.com and click the Choose Category button in the upper right corner (hopefully they have not re-designed their site after pushing this post).  I find the category that best suits my problem and view the list of approaches.  What makes the toolbox so awesome is the user voting.  For this example, the Rails Authentication category indicates devise is the leading GEM.

Step 2 – railscasts.com

I next go to railscasts.com and watch the Ryan Bates video on my selected GEM.  Truthfully, Ryan Bates is one of the best online instructors I have ever seen and his video casts are to the point and very well-done.  I should know having worked on e-learning technologies for years.  The best part about the railscasts is you actually see how the technology works and what it takes to integrate it.  In other words, you get a “try before you buy” type of experience to see if the solution meets your needs.

Step 3 – stackoverflow.com

My final step is to make sure the technology is compatible with my stack and is not facing any major issues.  I do a search on stackoverflow to see what questions people are posting and what solutions are provided.  After a quick perusing of the posted questions about devise and rails 3, I see nothing to prevent me from moving forward.  Decision made.

Step 4 – github.com find the README for the GEM

Make sure you always check the README filer on GitHub to validate the usage of the GEM.  Most GEMS provide helpful instructions and informative summaries of the functionality.

Step 5 – back to railscasts.com

This time when I watch the railscasts video I make changes to my application in tandem with Ryan.  He just does an excellent job of talking you through each step.  You should verify key steps against the README in case changes have been made since the cast was created.

Cheers!

Recommendations For Updating Your Technology (part 1)

How often do you as a developer upgrade your toolbox?  Do you sync to the nightly build or work from the last stable release for your open source tools?  I find that when I start a new project, that’s when I take the time to evaluate my approach.  Once a project is under way, however, I only re-visit if I need to add something new or I discover a much better way to solve a problem.  And I do mean much better, not just kind of better.  After all, upgrading your tools, or your fleet, or your pipes, has a cost even if there is something much better on the market.

I am at that point right now.  I am about to start a new project inspired by some demos I saw at the SF New Tech meetup this week in San Francisco.  Comments on the Ruby on Rails : talk group in Google groups helped me realize it’s time to move to Rails 3 and re-evaluate some my preferred GEMS like restful_authentication. What I really want to do is to start my project right meaning doing things even more the Ruby-way and using the best recommended tools and techniques.  But how exactly do you determine that?  Here’s how I recommend you do it.

Step 1 : Contact the experts you know

I have the advantage of working for a leading development company.  When I need to learn about a topic, I can email our architects, project managers and team leads and just ask them.  Truthfully, this is a great resource!  I also work some of my social contacts.

Step 2: Follow the experts you don’t know

This one is simple: @dhh on Twitter.  David Heinemeier Hanson is the creator of Ruby on Rails.  From there, I jumped to the Google groups used by the community including Ruby on Rails : core and the aforementioned talk group.  I am also a member of the Ruby on Rails group at LinkedIn.

Step 3: Use social as an expert

Go to sites that have good information but also feedback loops from real developers.  Stackoverflow is the king of these, but Quora is a new rising star on the horizon.  One of the guys I mentioned in step 1 turned me on to The Ruby Toolbox which is simply awesome!  You’ll find categories of tools there along with votes for the best approach in each category.  That’s how I found out my user account tool of choice, restful_authentication, was not actually the leading choice by developers.  Both devise and authlogic ranked higher than what I was comfortable with.  I may need to make a change.

In my next post, I will list what I ended up with as my new toolbox for developing Rails applications.

Enjoy!

Switching Rails IDE to Find Out NetBeans is Really Cool

I’ve been using Xcode 3 for my Ruby on Rails projects since learning the language because the tutorial I followed to learn the framework did the same.  Xcode was easy to use and had the basics of what I needed.  Keep my files organized.  Don’t slow me down with unnecessary steps or hard to find features.  Easy enough.

A few months back I searched to see what other IDEs people were using and NetBeans came up as a nice choice.  The price was right, free, thanks to Sun open sourcing the tool.  NetBeans built it’s rep on Java and many Rails developers seemed pleased with it.  I downloaded the product, installed it, and then like so many of my investigations I abandoned the task for some deadline or need to be productive.  After all, switching your IDE is a significant task.  Your productivity goes down as you learn the new actions and key strokes.  It’s like when you move to a new neighborhood.  It takes a while to figure out where to get the best take out, so you eat what is convenient for a while even if it’s not that good.

Fast forward to the present, I decided to create a new iPhone app to play around with location services.  I upgraded my iOS and that lead to an Xcode 4 upgrade, new provisioning, etc. etc. Many of you know this pain.  I spent more time futzing around than learning though in the end I did show a map of where I was on my phone.  I went back to my Rails project and that’s when I realized the hidden ramification of my pursuit.  Can you guess?

I had upgraded my development environment for Rails without really thinking about it.  Darn it! There goes my productivity as I learn the new tool that is actually a bit different from what I am used to.  Not one to sulk, OK I might have sulked a bit, I decided to use this as an excuse to dig into NetBean again. I am happy to say I am a NetBeans convert for sure! Here’s why.

First, getting my project up and running was simple.  I started a new project, selected the option to start my Rails project from existing source, and I was off and running.  NetBeans had inferred just about everything I would want from looking at my folders.  My database was linked.  My source code repository was hooked up.  Really, they did a good job of connecting the dots.

What’s more, the IDE offered a bunch of features I didn’t get in Xcode either because they were not there or not easy enough to find.  NetBeans treated my classes as objects adding extra navigation and functionality.  I liked the way Find worked.  My windows and tools were all integrated where as with Xcode I ended up creating a hodgepodge of applications including terminal for shell scripts, svnX for source code management, and others.

I realize of course that Xcode or Xcode 4 may have some or all of what I am already using in NetBeans.  But that’s the key point.  NetBeans got me there faster and without slowing my productivity that much.  Switching my IDE, while accidental, has actually lead to a richer set of tools in my toolbox.  I am almost ashamed to admit I didn’t look harder for these with Xcode.

For you Eclipse or Xcode 4 fans, please don’t take offense.  Selecting your IDE is really like picking a car.  You’re going to spend a lot of time with it and the overall experience matters as much as if it has features you want like integrated GPS and bluetooth, anti-lock breaks, or a sun roof.  I am sure I could be just as happy with these tools long-term as I expect to be with NetBeans.  But for now, I am smitten and comfortable driving the car I have.

The one piece of advice I would offer is you may want to consider learning Rails before moving to NetBeans.  NetBeans does so much for you that you might not learn the guts of the framework and how to really develop in Rails at the lowest levels.  For example, doing a migration from a dialog box is not the same as learning migrations at the command line and all the nuances that come with.  Still, if you are shopping for a new car, I mean a new IDE, I’d put NetBeans on your radar.

Cheers!

Mobile Architecture Considerations

This post was written by one of our architects William.

Mobile is here to stay and offers the growing possibility of new opportunities. Application systems using mobile devices will require an analysis of architectural constraints and further considerations. Let’s take a look.

Mobile devices are small, portable, powerful machines that are usually connected to services. Still, they are limited. They are not for intensive processing. The battery is drained very easily when using features, so care must be taken to reduce resource usage. The bandwidth is limited for communications and has an associated cost too. They have limited display capabilities, memory and storage space. Any design must take these limitations into account.

A system using mobile components may have different configurations.  Here are the most common ones and their implications:

1. A native, standalone app — These are applications that use the mobile device’s features to its maximum and may not require much communication (internet access).
2. A client-server app — These are applications that have part of the functionality in the mobile device, part in a server. They require communication and data transfer.
3. A Web App — These are very common, applications written in web. The client in the mobile device is just the browser and all the functionality is on the server.

Depending on the application type, architectural considerations may vary. Also, if the application is created from scratch or if it is a mobile exposure of an old app. The following is a list of issues the architect should check or take into account when creating or adjusting the system architecture.

Communication and data transfer. This is really important when designing the app or when porting a normal app into the mobile world. Communication consumes battery and data transfer has its cost in time and money. It is advisable to keep communication to a minimum. That means aiming for minimalist interfaces on web apps. For client-server, the transferred data should be information (meaning detailed info is “cooked” in server and just the require info is sent to device). Also, review the possibility of using compression. UI should reduce the use of images and other media like video or audio.

Processing. As mentioned, the device is not a super computer. The process design should consider using the device for processing some data under a threshold, or balancing processing and data transfer with a server. Consider a charting example.  The chart can be generated in the server and sent as an image, or the server can send the chart data for the device to render the chart, or even send the detailed data for the device to process and render. It depends on the amount of data, the processing power of the device and the load in the server.

Memory. When working with the native part of the app, consider macro elements and static processing. The idea is to minimize the memory use, in terms of space and allocation frequency. Consuming all the memory is one issue, consuming less memory but continuously creating objects and destroying them is also bad.

Security. This is an important issue. Using encryption in communication increases processing. Also, care must be taken when storing credentials in the device or deciding to send the credentials over the air. Consider encryption of stored data. Also consider having data backed up in the server, in case the device is stolen, lost or destroyed.

System interactions. As part of a system, the mobile device may be seen in the architecture as a process or a functional element too. It should be taken into account that the device may be offline at times, or may be lost, in which case the system should keep working, either side. Architecture must contemplate incomplete or “frozen” transactions that may occur when the device fails to complete the steps or takes too long to complete them. It must also consider mobile devices to be disconnected in any moment, and thus there should be ways to recover transactions.

A careful analysis of the goals and possibilities of mobile should be conducted, as the devices will open new possibilities but also post some restrictions and modifications to common architectures. Architect must avoid pitfalls like thinking the current server or apps can be ported as they are directly to mobile, or assuming the load of opening the server to support also mobile is manageable without proper load testing. Finally, any adjustment must be drive tested in the device, as the user experience may cause a project to fail if mobile special issues are not considered.

Every solution is different.  That is why these considerations are so general. Each solution should be treated in a special way, based on the current needs.

Ordering a Child Table Column In NHibernate

The following post is from our development engineer Jorge Cortillo.

Recently I ran into some issues when I was trying to order a column from a child table.  The relationship between Parent table and Child table is going to be represented as a Foreign Key (also this relationship could be referenced without using a Foreign Key constraint, this scenario most of the time occurs in legacy databases) and in our mapping file we are going to have something like this:

ParentTable.hbm.xml

<bag name="ChildTable" inverse="true" lazy="false" cascade="all">
<key column="ParentID" />
<one-to-many />
</bag>

ChildTable.hbm.xml

<many-to-one name="ParentTable" column="ParentID" />

Our Properties are going to have the same reference:

ParentTable.cs

public IList<ChildTable> ChildTableList { get; set; }

ChildTable.cs

public ParentTable ParentTable { get; set; }

If you notice I’m not using “virtual” after public that’s because I declared my mapping files as default-lazy = false, so any proxy is going to be created.

Now let’s say that we have, besides this relationship, a couple of properties at each POCO:

ParentTable

Int ParentID
String Description
IList<ChildTable> ChildTableList

ChildTable

Int ChildID
String FirstName
String LastName
ParentTable ParentTable

Well, now that we have a clear scenario, let’s go with our problem and how I solved it.  Let’s say that the Business User requests that you have to order the results of ParentTable ordered by FirstName and LastName (from ChildTable).  At first, if you think about a sql statement it should be pretty simple, because you just need to add an Inner Join then add an Order By ChildTable.FirstName ASC, ChildTable.LastName ASC.  But how can we translate that into NHibernate? The answer is really simple.  First, you need to explicitly declare the join.  Then proceed to add the order statement, like this:

Session.CreateCriteria<ParentTable>("pt").CreateCriteria("ChildTable", "ct", JoinType.LeftOuterJoin);
Notice that the JoinType can be LeftOuterJoin, RightOuterJoin or InnerJoin.  And finally proceed to add the order statement like this:
criteria.AddOrder(Order.Asc("ct.FirstName"));                           
criteria.AddOrder(Order.Asc("ct.LastName"));

That’s all the code you need if you want to order a list from a child table.  If you want to return a list from a ParentTable ordered by any of its columns, you don’t have to explicitly declare the JoinType.  NHibernate is going to do that for you.  In this case, you’ll only need add AddOrder(Order.Asc(“columnName”)) and you can use Order.Desc also.

You can add more references if you want to order your result query by any child table.  It’s not limited to only ParentTable – One Child Table.

Enjoy!

Data Modelling Tips

Here is a post from our engineer José Luis.

A few days ago, I finalized a project where I did a complete database model and design.  I would like to share with you my best tips that I think are the most relevant when you are creating a database model:

• Databases play a main role in application development  as data repository, generally implemented as a relational database.  Considering other options  such as record sets, flat files or custom file formats, none of these are robust or safe as a database.
• Data modeling is the process of mapping real world information to logical representations of data. Here it is important to think about data from logical standpoint without being concerned with how tables and columns will in your database.
• Keep in mind that a bad database design will inevitably create a severe scalability problem and is often extremely difficult to modify as time goes on.
• Describe your data model as the map containing all the pieces of information needed by you application and how data relate to one another. It also provides a non-technical users view of data and can be very useful to gain user acceptance of the overall application design. When data model is properly designed, it becomes the platform agnostic logical “blueprint” for a physical database to be developed.
• A good data model will provide better performance to your RDBMS by following standard data modeling rules to eliminate data anomalies such duplicating data. Also data accessibility makes data easy to understand by defining entities and tables that categorize the data you are working with, then analyzing your data reporting or data warehousing will be considerably easier.
• Understand and apply the “building blocks” in your data model by understanding entities, attributes, relationships and domains.
• As you already know, the Normalization process is another key task in data modeling and it defines as the process of grouping data in a logical way to avoid duplication and data complexity.
• Normal forms are named simply according to their occurrence in the sequence. Typical First, Second and Third normal forms (1NF, 2NF and 3NF) are applied as progressive forms of a data model, each one stricter than previous. Also consider the Boyce-Codd Normal Form (BCNF) and the 4NF (primary key without multiple value dependency) and 5NF (ternary relationships).
• Evaluate if you need to apply Denormalization to your data model for punctual situations like extensive reporting and massive warehousing.
• Always handle your data model file versioned with tools like CA Erwin, Sybase Power Designer, Embarcadero ER/Studio, MySQL Workbench, or Oracle Designer.

I hope you can consider the topics described above and get better data models that will be the root for robust and top-notch data repositories.

Avantica Has Known Java For A Long Time

A few months back, we attended the JavaOne conference in San Francisco.  The conference these days is an adjunct to Oracle’s other conference and clearly is a side note to the database technology taking center stage.  Java was such an integral part of the Internet explosion and it makes me a bit nostalgic to see how it is not the central player it once was.  Yes, that’s right, I am feeling a bit nostalgic for my old friend Java who doesn’t entice me into coding projects like he used to and is just not as lively at parties as my new friends Ruby and Rails.  Java was like your station wagon before SUVs came along.  If you had Java, you could take the family anywhere.

The language was developed by James Gosling at Sun and released in 1995.  The timing was perfect for the first Internet boom that curtailed around 2000-2001.  One of our architects provided me this helpful information about Java’s origins.  Java was originally designed for embedded systems, but then it was ported to the desktop where it failed in the most painful way.  Java next evolved into a code-on-demand language with Java applets at a time when Javascript was still not as good in RIA and ActiveX was the proprietary competitor.  The introduction of the Enterprise Edition and Enterprise Java Beans established Java as the go to back-end system language (thanks William!).

My first Java project was at a company called Cuica, where we built an advertising marketplace using on Java.  The product was a precursor to ad words if only it had survived the bust.  Interestingly, Cuica was my first experience with outsourcing as well.  The company we hired to do the job was Avantica!  That’s right, it was Avantica’s first Java project and mine as well, and my first time working with the guys in Costa Rica.  In fact, the lead developer was a guy named Henry who is the head of development for Avantica.  You can read a little more about that experience here.

In honor of my old friend Java, I asked a few of the guys who worked on some early projects why they felt Java became the innovation and success that it was.  I hope you find there answers interesting:

“Java was a promise of a language that will keep the power of C++ without its complexity, with a big plus: running everywhere.”

“Best Innovation? I cannot name just one thing, and the ones I may think of are not necessarily part of the language, but the community.  For instance, the specification process created important standards that many vendors adopted, which lead to a major adoption and fast growing of solutions.”

“The simplifications and enhancements weren’t trivial: automatic memory management, standardization among data types, the introduction of interfaces and a simplified inheritance design, the usage of packages, among many others. These features solved real problems developers were having with C++, at the time the main language used for development.”

“The two features of Java that most excited me from the outset were Portability and Automatic Memory Management.  At the time JDK 1.0 was released I was working on a File Transfer application that I was supporting for DOS, OS2, Windows 3.1 and Netware. The idea of building a single application for all of these platforms had obvious appeal.”

“My first Java application on JDK 1.0 was a secure communications client/server application design for trading game assets for one of the first persistent universe games called 10-Six. My lasting impression from developing this application was how little time I had to spend chasing down memory usage related bugs. As a C/C++ programmer I was accustomed to spending up to 50% of my time on memory management and tracking memory leak bugs.”

“The infrastructure of frameworks that have come from the Java community.  These frameworks made Java/J2EE the premier web development framework. Hibernate/JPA solved the long running headache of managing the persistence layer in J2EE applications.  Spring enables management of all frameworks in J2EE applications. Central to the Spring Framework is its Inversion of Control container, which provides a consistent means of configuring and managing Java objects using callbacks.”