I was previously a senior software engineer at Google X (Loon), and now I’m a YC founder at Stella who builds software faster than ever, thanks to AI.

100% of my code is written with AI. I accomplish 10x more, way faster. AI prototypes entire products for me, fixes bugs while I’m meeting live with customers, and heck, I even used it to build a multiplayer fish simulation in one single instruction! At this point, I don’t think I could go back to the old way of building.

My goal with this post is simple:

To inspire you and show that anyone can build with AI - no matter your background.

Read this article

While many people doubt that you can intern at a top company without going to a target school like MIT or Stanford, it’s definitely possible. I go to a midwestern state school that’s not known for its Computer Science department, but I ended up interning at Facebook and Google. Hopefully, these tips will help you to do the same!

The main difficulty I’ve encountered in coming from a school that’s not well-known for CS is that it’s very tough to get an interview. I know people who interviewed with Google their freshman year just for having a decent GPA at MIT. As a student from a lesser-known school, you won’t have that luxury.

To get the interview, you need a way to stand out. While Stanford students stand out by going to Stanford, you’ll need to prove your worth to make it to the interview process. Here are a few ways to do so:

• Have prior internships. While you may not be able to land an internship at your dream company by next summer, you may be able to intern at another tech company. If your school has a career fair, utilize it to get your first internship or two. Even if your first internship isn’t with a top SV company, you can still learn a lot and have fun.
• Talk to companies directly. If you have a friend who works for a cool company, ask for a referral. If you’re in the Midwest, you can meet some awesome companies by going to UIUC’s Reflections and Projections conference.
• Get involved in your school’s CS organization. If it doesn’t have one, create one! Tech workshops and mini hackathons can go a long way in helping out fellow students and can be tons of fun. It’s a blast to hang out with fellow coders and work on side projects.
• Make good grades. Having a good GPA is always helpful in getting noticed, but it’s definitely not a requirement at most major tech companies. Oddly enough, I’ve found that midwestern companies care a lot more about your GPA than your typical Silicon Valley tech company does.
• Do side projects!! Hopefully you’re majoring in Computer Science because you enjoy it, so side projects should come naturally. This is probably the number one thing you can do to get noticed. Having an active GitHub is instantly a huge boost to your credibility as a potential intern.
• Go to hackathons. Hackathons are a great place to meet amazing coders from all around the country (and world!). If you do well, all the awesome sponsor companies will see what you’ve built. Other types of competitions like TopCoder or Kaggle can also help you get noticed.
• Teach yourself. If you’re interested in a topic that isn’t taught at your school, see if there are any Coursera, Udacity, or EdX courses on the topic. Employers love to see that you’ve taken the initiative to learn things on your own.
• Teach others. By helping others with CS concepts, you solidify your own knowledge. Helping teach a course shows employers that you’re knowledgeable and can communicate well.
• Do research. Researching an interesting topic shows off your ability to work on hard technical problems. Additionally, the professor you work with may have industry connections that can help in getting an internship.
• Write a resume. After accomplishing all this awesome stuff, you need a way to present it to employers. I like this guide to writing a resume.
• And finally, apply!

After getting an interview, the playing field is pretty level. You just have to pass the interview. This portion of getting a CS internship is pretty well-documented, but here are a few tips:

• Cracking the Coding Interview rocks. It’s an awesome resource for preparing for technical interviews.
• Implement common data structures and algorithms. I found these Princeton algorithms slides really useful in learning new data structures and algorithms. Bonus points if you put your implementations on GitHub.
• Do mock interviews with friends.

Good luck with getting the job! :)

Note: Don’t feel like you need to do all or even the majority of these things to get noticed. It’s just a list of many things that could help get an interview.

Read this article

While the Paperclip gem is awesome for most Rails use cases, it doesn’t have support for saving files to a database. In some scenarios, access to the filesystem or an external service like Amazon S3 isn’t feasible. Or maybe you just want to put your files in the database.

As it happens, file upload in vanilla Rails is simple.

First, create a model that will store the file. Give it the following attributes:

• filename:string
• content_type:string
• file_contents:binary

Note: To quickly scaffold the model to save some keystrokes, do rails g scaffold document filename:string content_type:string file_contents:binary in your terminal.

Here’s the code for the model and migration:

# app/models/document.rb
class Document < ActiveRecord::Base
end

# db/migrate/20140602005921_create_documents.rb
class CreateDocuments < ActiveRecord::Migration
  def change
    create_table :documents do |t|
      t.string :filename
      t.string :content_type
      t.binary :file_contents

      t.timestamps
    end
  end
end

Next, add a file input to the model’s form.

<!-- app/views/documents/_form.html.erb -->
<%= form_for(@document) do |f| %>
  <div class="field">
    <%= f.file_field :file %>
  </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>

Next, you need to make sure you allow the file as a parameter so you can use it in the model.

# app/controllers/documents_controller.rb
def document_params
  params.require(:document).permit(:file)
end

Finally, update the model to read and save the file. In Rails, a file input is passed in as an UploadedFile that can be treated like a normal file. I prefer to save the file in the model initialization.

# app/models/document.rb
def initialize(params = {})
  file = params.delete(:file)
  super
  if file
    self.filename = sanitize_filename(file.original_filename)
    self.content_type = file.content_type
    self.file_contents = file.read
  end
end
private
  def sanitize_filename(filename)
    # Get only the filename, not the whole path (for IE)
    # Thanks to this article I just found for the tip: http://mattberther.com/2007/10/19/uploading-files-to-a-database-using-rails
    return File.basename(filename)
  end

So now you have an application that users can upload files to, but they still can’t download them. We can make the show action of the documents_controller download the file. To do so, simply send the file data saved in the document.

def show
  send_data(@document.file_contents,
            type: @document.content_type,
            filename: @document.filename)
end

You’ve now seen everything it takes to make file upload and download work in vanilla Rails! If you want to do validations on attributes like file size, you’ll need to make a slight change to the initialization in the model so the file object can be accessed in the validations.

# app/models/document.rb

validate :file_size_under_one_mb

def initialize(params = {})
  # File is now an instance variable so it can be
  # accessed in the validation.
  @file = params.delete(:file)
  super
  if @file
    self.filename = sanitize_filename(@file.original_filename)
    self.content_type = @file.content_type
    self.file_contents = @file.read
  end
end

NUM_BYTES_IN_MEGABYTE = 1048576
def file_size_under_one_mb
  if (@file.size.to_f / NUM_BYTES_IN_MEGABYTE) > 1
    errors.add(:file, 'File size cannot be over one megabyte.')
  end
end

I’ve created an example file upload application showing everything in action together. The source is on GitHub.

If you enjoyed this article, follow me on Twitter for more like it. Happy hacking!

Read this article