The advantages are plenty for Apple, but the switch comes with its complications. For the scope of this article, I would like to handle the following challenges:
While Apple can introduce more than 8 cores in its upcoming A14 chip, for consistent, long, single-threaded workloads, AMD64 architecture remains king.
App Developers need to compile their apps against both AMD64 (for backwards compatibility), and ARM architectures (not to mention x86 which was supported until the release of MacOS Catalina).
In order to create a smooth transition, like the one Apple pulled off with the switch from PowerPC (Motorola and IBM) to x86 (Intel), here’s how I think #apple can create a similar transition:
Only time will tell how Apple will handle this. Nonetheless, this is exciting time for the industry. ARM has been adding to its massive base on small devices like phones and tablets, small laptops like Chromebooks, AWS introducing Graviton on servers, and now Apple on laptops. The future of devices with no fans and no heatsinks is getting brighter. What do you think? Let me know what you think in the comments section below.
]]>The following tutorial uses: us-east-1, Ubuntu 14.04, Rbenv, Foreman
We will create a new role that we will be launching our EC2 with. EC2 instances launched with the new role will be able to:
Edit trust relationship:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "codedeploy.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
I prefer setting up a separate VPC for every application, feel free to ignore this step if you don’t really care about this. Class B private IPs provide a decent number of hosts and that’s what I’ll use here.
Using multiple subnets will allow Scalability Groups to utilize multiple availability zones improves redundancy.
For Internet requests to reach your gateway, you need a routing table.
To make things more tidy, we will create a per-VPC security group and we will attach it to all resources we create. This would allow globally enabling certain ports or block certain IPs from accessing all resources.
We now need to create an AMI that has all our project’s OS dependencies installed. If you already have an AMI, skip to “Install CodeDeploy Agent”
We will use a setup similar to
Heroku’s handling of Procfile
by using a single AMI that can dynamically be assigned one of the processes
defined in the Procfile.
Launch a new EC2 Instance and make sure you have AMI Role set to: CodeDeployProfile.
Install Rbenv and your chosen Ruby version:
sudo apt-get update
sudo apt-get install git-core curl zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev python-software-properties libffi-dev
cd
git clone git://github.com/sstephenson/rbenv.git .rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL
git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bashrc
exec $SHELL
git clone https://github.com/sstephenson/rbenv-gem-rehash.git ~/.rbenv/plugins/rbenv-gem-rehash
rbenv install 2.2.3
rbenv global 2.2.3
ruby -v
Reference: GoRails
To install the agent, run the following commands:
ssh -i {PEM_FILE_PATH} ubuntu@INSTANCE_IP_OR_DNS_NAME
sudo apt-get update
sudo apt-get install awscli
sudo apt-get install ruby2.0
cd /home/ubuntu
# Replace us-east-1 with your VPC region.
sudo aws s3 cp s3://aws-codedeploy-us-east-1/latest/install . --region us-east-1
sudo chmod +x ./install
sudo ./install auto
If you get an error on aws s3 command, then you either didn’t launch the EC2
instance with the role we created in IAM section or you didn’t
follow the steps correctly.
Reference: AWS CodeDeploy
We need to have our application process start automatically on machine start. In order to get this to work, we will be using Ubuntu’s Upstart.
The following script uses Foreman to run the correspondant process defined
in the Procfile.
Make sure you install Foreman gem by running the command:
gem install foreman
Then, proceed to creating the Upstart script.
sudo cat > /etc/init/app.conf << EOS
respawn
start on (local-filesystems and net-device-up IFACE!=lo)
stop on [!12345]
setuid ubuntu
script
set -e
chdir /app/current
export PATH=/home/ubuntu/.rbenv/bin:/home/ubuntu/.rbenv/shims:$PATH
export RAILS_ENV=production
export PORT=3000
export PROCESS=$(cat /app/role)
echo " * Starting process: $PROCESS..."
foreman start $PROCESS
end script
EOS
The files can be accessed directly via URL:
http://owahab.github.io/downloads/samples/{file}
The list of samples can be found here: https://github.com/owahab/owahab.github.io/tree/master/downloads/samples
Enjoy!
]]>However, in some cases, you can’t have Nginx running in front of your application server. For example, when you’re running on Heroku.
To serve your assets more efficiently, a good way to do it is to serve those assets from a CDN. For this, my favorite pick is Amazon AWS CloudFront.
You need an Amazon AWS account to get this done. Log in to the CloudFront control panel and select ‘Create distribution’. When prompted for the delivery method, select ‘Web’.
You should type the domain name for your application as the ‘Origin Domain Name’ field. Just make sure to include www if you serve from www because CloudFront won’t play nice with redirections. You will see 302 Moved Permanently and CloudFront will redirect back to your domain every time you request an asset.
Also make sure you choose ‘Whitelist’ from the ‘Forward Headers’ dropdown then pick ‘Origin’ from the ‘Whitelist Headers’ and hit ‘Add »’.
Once the distribution is created (takes less than 10 mins), test it by requesting an asset from your newly created CloudFront distribution.
http://www.example.com/assets/application-<HASH>.css
becomes:
http://<YOUR DISTRIBUTION SUBDOMAIN>.cloudfront.net/assets/application-<HASH>.css
Now we need to configure Rails to serve assets from CloudFront. In order to do so, you need to uncomment and modify the following line:
# config/environments/production.rb
config.action_controller.asset_host = "<YOUR DISTRIBUTION SUBDOMAIN>.cloudfront.net"
When you deploy this, your application should start serving assets from CloudFront. Yay!
So far, your JavaScript, Stylesheets and images would work fine. However, some other asset types like fonts won’t work due to CORS (Cross-Origin Resource Sharing).
In this case, you will see the following error in Chrome Console:
Font from origin 'http://xyz123.cloudfront.net' has been blocked
from loading by Cross-Origin Resource Sharing policy: No
'Access-Control-Allow-Origin' header is present on the requested resource.
Origin 'http://example.com' is therefore not allowed access.
This basically means that your Rails application should grant CloudFront access to its by-default-private assets like fonts because only then CloudFront will pass the CORS headers back in its response, browsers will know that CloudFront (which is the owner of the asset from the browsers’ point of view) is granting your domain access to CloudFront’s assets.
One easy way to do this is by adding rack-cors to your Gemfile:
gem 'rack-cors', :require => 'rack/cors'
After running bundle, you need to configure your application to insert the
headers in the Rack Middleware. The following sample is quite permissive but it
will suffice for the purpose of this blog post:
config.middleware.insert_before 0, "Rack::Cors" do
allow do
origins '*'
resource '*', :headers => :any, :methods => [:get, :head, :options]
end
end
This, combined with the ‘Whitelist’ option we chose in the first step, would allow CloudFront to serve your fonts correctly.
References:
I have had already joined few startups at different stages but OverC Studios was the first time I start from scratch.
I made a lot of mistakes, learnt a lot of lessons. Most of these lessons are already mentioned in the great book “The Lean Startup” by Eric Reis. I highly recommend the book for everyone working for a startup, not just founder.
Approach your ideas using the most straightforward way. Fail fast or succeed fast.
Another very common mistake was trying to ship something that we are not ashamed of. Lesson learnt: if you are not ashamed of your product then you probably haven’t built anything.
One of the few things we did right was hiring the right team. For a startup in this early stage, we needed a team that can pivot fast, learn a lot and build things that we weren’t sure how their final status would be.
I can’t emphasize on the importance of your company identity. Don’t waste your time trying to be everything for everyone. We wasted a lot of time trying to get services and build products and that time was very dear.
It has been a great journey and I truly enjoyed every day of it. Goodbye OverC Studios.
]]>You need to upload an image from a mobile device to a Rails application which uses Paperclip.
Your model might look similar to this:
class User < ActiveRecord::Base
attr_accessible :name
has_attached_file :image,
styles: {
small: '90x90#',
medium: '160x120#',
large: '300x200#',
} And you want to be able to upload user images.
You need to add the following to your model:
def image_data=(data_value)
StringIO.open(Base64.strict_decode64(data_value)) do |data|
data.class.class_eval { attr_accessor :original_filename, :content_type }
data.original_filename = "temp#{DateTime.now.to_i}.png"
data.content_type = "image/png" #TODO: get content type from file
self.image = data
end
Voila!
]]>###Preamble
Rails is an extremely mature RAD Framework to the extent that it’s currently driving the MVC bandwagon. A lot of effort has been put by Java, PHP, Python and a lot more languages’ communities to port or clone what Rails has offered. CakePHP, Symfony (PHP), PHP on Trax, Code Igniter (PHP), Grails (Java) and Django (Python) to name a few.
The major pillars of Rails strength are:
###Reusing open source components
With a central repository of reusable modules, numbers can easily speak for themselves. There has been 56,022 gems (Ruby and Rails modules/plugins) created since July 2009. The second best after Rails is Drupal (LAMP CMS) with a shy 19,358. References: rubygems.org and drupal.org.
###Creating reusable components
Rails has a very unique advantages over many web application frameworks (including but not limited to PHP ZendFramework, Drupal and Django) which is being very strict MVC model, great attention to core backward-compatibility, being an integrated framework and the Ruby gems architecture (dependency management, package management, etc) has helped making gem creating a very easy job. Reference: being a Drupal module maintainer for years (http://drupal.org/user/75702) and a Ruby gems maintainer for couple years.
###Productivity
With Rails’ scaffolding, easy Form APIs, strong ORM, Ruby’s simple syntax, huge resources (documentation, tutorials, podcasts, video casts, code samples, etc) and being open source, starting a new project from scratch can not be quicker. Learning curve has always been the greatest challenge when starting with a new technology. With Ruby on Rails, teams I worked with started producing working code since day 1 and while still knowing very less about both the language and the framework. The great thing about Ruby is that it’s a mixture between Java, PHP, Perl and Lisp which makes it a lot easier to learn for our team where everyone is coming from Java and PHP background.
###Deployment
Ruby on Rails currently offers a plenty of possibilities to run it on production , it can even run under Apache, the way PHP does. Which makes it very easy to install on development and production. With a lot of mature deployment tools like Capistrano, updating code and database on production is an easy job. Rails also leverages a great deal of support from cloud providers: Heroku, Amazon AWS, and EngineYard to name a few.
###Testing
With Rails, Unit Testing is integrated in the framework, Behavior testing tools like Cucumber are very mature, UI testing tools are already used in other technologies (like Watir). While we won’t start with all these types of testing, we will definitely increase our quality by automating testing on many levels which is something we, as a small team, need to do.
]]>I usually download lots of files and I keep trying to cleanup my Downloads folder in so many ways. First, I configured every application to download in its own folder so I had Firefox, iChat, Mail, etc…
This didn’t really help. When the time comes to cleanup the Downloads folder, I usually need to delete very old downloads because I no longer need a software update from mid-2009.
So next I tried one of Firefox’s extensions to organize my downloads and used Glims for Safari. The idea was to organize downloaded files in a directory hierarchy where I can identify older files and remove them.
The problem with that solution is that it didn’t work for all the applications I use so I decided to write a script to do that for me.
Writing that script in Bash, PHP or Python is an easy job but I wanted to do it the Mac way so I created this AppleScript and attached it to the Downloads folder using Folder Actions in OS X.
http://gs.statcounter.com/#browser_version-ww-weekly-200827-200951
Viva Open Source!
]]>GMail:
Google was the easiest mail vendor to deal with, it relies solely on an open standard called SPF which is simply a TXT record a domain owner can put on his domain’s DNS zone to state that the domain is fully responsible for e-mails sent from it under specific circumstances. Read more at http://www.openspf.org/Introduction In the OpenSPF website you will find a wizard that will help you generate your SPF signature. After adding the SPF TXT record, e-mails started to appear in the Inbox instead of junk. I must confess that I strongly believe that GMail does NOT discard any e-mail coming to your account even if it recognized it’s even a phishing e-mail!
Yahoo!:
Yahoo is also fond of open source solutions and the folks there started relying on DomainKeys Identified Mail, aka DKIM, which is a collaborative work between many IT big names like: Alt-N Technologies, AOL, Brandenburg Internetworking, Cisco, EarthLink, IBM, Microsoft, PGP Corporation, Sendmail, StrongMail Systems, Tumbleweed, VeriSign plus Yahoo! for sure. PS: Microsoft was participating in DKIM and then it used its own technology instead of DKIM! These guys keep surprising me. Anyways DKIM is a bit tough solution since it requires patching your mail server to attach your DKIM Public Key with every outgoing e-mail which is then being matched with what the mail receiver requests from the sender domain and in case they match then Yahoo, for example, will allow this e-mail to its inbox if the sender domain isn’t blacklisted by Yahoo or by any public blacklist. Read more at http://www.ietf.org/rfc/rfc4871.txt The interesting thing was: when Yahoo doesn’t find a DKIM in the message, it falls back to SPF and will behave like GMail will do with a message.
Hotmail:
Microsoft, as I mentioned above, was collaborating in the DKIM. But they use their own technology, called SenderID. Sender ID is basically SPF with Microsoft’s spices. SenderID is a caching system for SPF records. Thus you will find things a bit quicker if you e-mailed senderid@microsoft.com to inform them you changed your SPF record or created one. Then they will reload your domain’s cache. Read more at http://www.microsoft.com/senderid Once again this means that Microsoft relies on SPF. After creating SPF record for the domain under investigation, e-mails started to appear in Hotmail’s junk mail which isn’t expected and is an indicator that there’s something else to do.
I hope this helps anyone.
]]>Afterwards I deceided to put Rails versus Cake PHP, a PHP framework that works on all recent PHP versions from 4.3.2 till 5.0 (I haven’t tested it on PHP 5.1 but I think it will need some hands-on work to have it error-proof).
I started by creating a simple e-commerce database-driven site with them both and overall result I get is: I really see that Cake PHP is a PHP version of Rails. But here’s what I found in details:
Conclusion: I liked how creating blogs, forums and other famous applications is some lines of code, things can go easy with your combo-sized applications, I also liked the idea of structuring your applications the same way, this has two sides: it will allow everyone to understand your data flow, we will all enjoy ease of coding and refactoring other’s code, and this is the good part of it, the bad part is simply it will allow everyone to fool your application because everyone knows your directory structure, this is a big security risk –IMHO. And unless your choice of the framework is right, you may find yourself having many security halls not because what you types, it’s because the framework has these bugs already installed! I do not think I can afford the time to debug a framework, thus it’s better off using a framework of a reasonable community to have my bugs solved quickly.
I think if you’re in a hurry to start an application, or have a very near deadline for an application, you should take a look at your flavor of MVC framework (Rails or Cake), you will be astonished. But I, for many reasons, don’t like having everything going that rapid, I still won’t go the MVC framework way without getting things more obvious and more stable.
]]>But I ran into trouble with Rails after the installation, Rails said: “Rails does not work with Ruby version 1.8.3”.
After some search and a friend’s help, it appears that you have to do the following BEFORE you follow what’s in the article: download your architecture-specific packages from:
http://packages.ubuntu.com/dapper/interpreters/ruby1.8
Then dpkg -i for both packages.
Finally apt-get install rails
Now you have Ruby 1.8.4 on Ubuntu.
Enjoy!
]]>The major problem with PHP5 was its bad backword-compatibility with PHP4; forget about PHP3; thus major PHP scripts specially open-source mostly faild to work on PHP5 environment. The reason I saw behind this failure was mainly in the pass-by-reference since PHP5 passes by reference while PHP4 passes by value (which is extremely strange thing).
Anyways, I; like many PHP coders; started to gather news and stuff about PHP5: what’s new, how to convert current code, and so forth. I do not think I was that late to do this but after I was OK with all the new stuff in PHP5 I suddenly read in the news about PHP6!!
I was really astonished! The point is: the duration between the release of PHP4 and PHP5 compared to the duration between the release of PHP3 and PHP4 gives you the impression that Zend is really keen to have the market and the developers setteled with every PHP version, and when all the juice is squeezed from the PHP version Zend releases the new version. So what happened? What changed all this?
The PHP6 Meeting in Paris has shown some great amount of features for PHP6, some of them are really long-awaited, but why lagging all this until PHP6? Why not just add them all to PHP5?
I; for one; think that if PHP5 is going to break most PHP4 programs and scripts with the changes applied to the OOP model, so what was the problem with adding the changes in PHP core that the meeting in Paris introduced to the core of PHP?
I strongly recommend all of us to hold upgrades to current PHP scripts until Zend sets a date for the release of PHP6 which is expected to be the end of 2006 or the mid of 2007, instead of upgrading current work twice.
]]>