Skip to content

giovannipbonin/ieee-program

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

579 Commits
extras/cheat sheets
extras/cheat sheets
 
 
.gitignore
.gitignore
 
 
LICENSE.txt
LICENSE.txt
 
 
README.md
README.md
 
 

Repository files navigation

The Internet-Taught Software Engineer - A Student-to-Student Class and Experiment

Note

Class Author: Giovanni Pascotto Bonin

  • I am more than willing, and would be happy to mentor anyone - who is highly motivated - in any stage and give advice based on my experiences. I am also just in the start of my career, but I've had to overcome all kinds of obstacles and there is plenty of advice I can give for people looking for jobs in the Bay Area. Feel free to email me: pbonin.giovanni@gmail.com

  • I decided to create this class to teach while I am the president of IEEE at the University of Miami to supplement the school's curriculum, open doors for students to engage in discussions and interactions on the subject, as well as create a foundational framework for our organization on campus for future semesters.

  • If someone else decides to run something similar to this on their campus, I am also running guest speakers (in addition to each of these sessions), and that's a really good way to engage professional experience in your organization, as well as have experienced engineers potentially help you with the program.

Acknowledgements:

  • There are many other sources I have used to create this guide and I am very thankful for all the people that have put them together. I have heavily used resources and structure from @jwasham's Google Interview University guide.

Communication

I was initially going to use a Slack channel for this, but then I realized that most people don't have their Slack account open all the time, and realistically most won't download the app and have notifications on. So we will be using the IEEE Facebook group chat, to take advantage of the sad fact that people are on Facebook all the time and thus will receive the notifications. Send me an email or let me know in class that you want to be added to the group. We will also send announcements on orgsync, so if you don't have fb it's ok.

Table of Contents

  • Week 0
    1. Announcement
    2. Tech Talk
  • Week 1
    1. About Silicon Valley, Google, Facebook, and Startups - Motivation
    2. Interview Process & General Interview Prep
      • Emacs and vi(m)
      • Unix and Command Line Tools
  • Week 2
    1. Algorithmic complexity / Big-O / Asymptotic analysis
    2. An Overview of Data Structures and Algorithms
  • Week 3 2. Basic Algorithms: Binary Search and Sorting 3. Recursion
  • Week 4
    1. Machine Learning - Supervised Learning
    2. Machine Learning - Unsupervised Learning
  • Week 5
    1. Heaps and Balanced Trees
    2. Dynamic Programming
  • Week 6 1 & 2: Graphs and Search
  • Week 7
    1. Knapsack problem and More Dynamic Programming
    2. Shortest Paths Revisited, NP-Complete Problems and What To Do About Them
  • Week 8
    1. Bitwise operations, Discrete Mathematics, and NP Completeness and Computability
    2. Caches, Processes and Threads, and other topics
  • Week 9
    1. Testing and System Design
    2. Putting it all together and Review
  • Week 10
    1. Practice

Week 0

Session 1

First meeting and announcement:

Here the plan is to announce the program to the general body meeting, get input from the students on final things they might be interested in learning on top of the program, as well as finding out times that will work for most people.

Session 2

Guest Speaker (CEO of Kairos Analytics): Feb 23rd 6:30 pm at MEA 202

Week 1

Session 1 - About Silicon Valley, Google, Facebook, and Startups - Motivation

Talk

Major interview tip

Before anything else:

  • Few people would reference professional athletes when talking about software engineering tips, but by having an attitude toward your career similar to that of an athlete toward his, there is a lot I've learned. One of my favorite athletes, Muhammad Ali, was asked how many sit-ups he would do and his reply was: "I don't count my sit-ups, I only count when it starts hurting, because that's when it really counts."

There is nothing like working your hardest in the road to achieving your dreams. This lecture series is just a compilation of advice both from various amazing people I have met, and some I observed on my own. I am passing this advice along, but keep in mind the only way for you to be able to solve new problems is to develop the foundation through discovery yourself. Practicing to solve these problems on your own is the only way to create those neural pathways.

I actually learned a lot about learning in this Coursera class I took in my last semester in college:

To practice, get one of the recommended books with a list of exercises and hammer through it! Do all these problems, do one per day, or do two, or three, depending on how much time you have. There's no excuse to not do at least one of them a day until you feel comfortable enough to go to an interview feeling that you will make it.

Success leads to confidence (conversely from what people believe), so the more you successfully solve problems the more confident you will be. Start small, build your skills, and you will make it. It's hard to properly emphasize just how helpful these books are.

Coding at the whiteboard - from HBO's Silicon Valley

The Purpose of This Guide - Everything I'd wish I was taught earlier on

This program will help you understand computer systems, algorithm efficiency, data structure performance, low-level languages, and how it all works together. These subjects are extremely important, and the hiring process for Google (and Silicon Valley companies in general) places a huge importance on them. There is no shortage of studying, the more you know about these subjects, the better.

Before I started college I started learning computer science on my own, although I'd wish I had started even earlier given I was already 17. But due to some obstacles in my career choices I didn't dive in until that point, but when I did I committed as if I was born to do this. Before college, I had a gap year. During that period, when I found websites such as Coursera, MIT OpenCourseware, and a multitude of other content on the internet such as free textbooks and all that, I realized there is nothing short of motivation that can stop any of us from becoming one of the best at any field we want to excel in.

When I started college, I realized that I could actually learn better on my own than I could learn in class, so if that's the case for you, embrace it and pursue your passion in the way you know works best. The goal of this is to be a list of resources that can be followed and give you a good coverage on what's important, specifically filling in the gaps left by a typical computer science or software engineering curriculum. It turned out for me that by the end of my college career I wanted to work for a startup, as that way I can have a bigger impact in something that is in its early stages and really needs to be pushed forward. These experiences with learning told me to go work for a startup fixing education with technology.

This is a long plan, and some interviewers will even tell you that some of this stuff is more advanced than you need. In fact, I found this guide after accepting my full-time offer with my favorite startup in the world (Coursera), and I am going through it now (for fun) since practice is never too much, and some of this stuff I haven't had time to cover before, but it is well worth it to be good at what we do.

So yes, it might be true that some of these things don't often show up in an interview. But that's until it does, and you start thinking to yourself DAMN this is my favorite company, I should really have spent that weekend learning about this, now I have to wait a year to reapply.

This is not the SAT or MCAT. The reason why software companies want us to know these subjects is because it is important for our jobs, and the more we know about it the more we can build, the faster we can create, and innovate. Although you might not be designing algorithms on a daily basis as a software engineer (although some engineers do exactly that), becoming good at this will develop the right way of thinking that you need to solve problems of all sorts in systematic and efficient ways.

Logistics

I remodeled the guide as a curriculum to be conducted on a weekly basis, as well as adding a lot to it. Again, it's a work in progress that I am doing in my free time, and I plan on properly breaking down the outline so that it evenly fits across weeks. We will try to meet twice a week and have extra content for the ambitious who want to do more at home, but the idea is that during the sessions we will cover one or two pieces of content for each subject and have extra to be done at home.

For those wanting to track their progress at home, just fork the repo and mark an [x] on the items you have done, commit and push it.

Instructions: not familiar with git yet? No worries http://rogerdudler.github.io/git-guide/ Or, if you are a University of Miami student, you have a free subcription to Lynda.com and you can take this quick start Git and GitHub course: https://www.lynda.com/Git-tutorials/Up-Running-Git-GitHub/409275-2.html

It's All About Discipline

  • People put too much emphasis on IQ as opposed to emotional intelligence. After a certain level of IQ what really matters is dedication, passion, and good discipline toward your work. Most of the famous genius engineers that we all know and heard of struggled with these topics too at one point, but with the right discipline and passion they became really good at it by sticking to it. So never be discouraged!

  • Check the home assigned readings and videos for "The Myth of the Genius Programmer"

What Silicon Valley looks like

Silicon Valley

Inspiration for these technical challenges we will tackle:

Resources that helped my career

  • Code2040: a wonderful fellowship program for Latinos and African-American students who want to work in Silicon Valley. It made a huge impact in my career by exposing me to the industry, and I spent a whole summer meeting extremely talented people working in companies across Silicon Valley who are also motivated to fix the world's greatest problems: www.code2040.org
  • Google: Seriously, use it. If you have a question, instead of beating your head against the wall, just Google it, unless you are doing an exercise and you are not supposed to Google the answer. But no one is supposed to know what a Turing Machine is without first learning it. So if you feel discouraged, just remember that it's never too late to pick up on something. There are so many resources out there for free.
  • Coursera (www.coursera.org): With the above in mind, Coursera made a huge impact in my career. When I realized I could learn anything I wanted from the best professors in the world, and for free. And that if I wanted to impress recruiters I could also get a certificate from Stanford. It really pays off to show you are investing in your skills. Disclaimer: the favorite startup in the world I mentioned I will be joining is Coursera, but that's the reason why I will be joining them, because it made a huge impact in my life. www.coursera.org
  • Pramp: I used this a couple times, it's a cool platform where you can schedule mock interviews with strangers

Reading at home:

[ ] Start reading 20 minutes a day (or whatever fits your learning style/routine): Book: How Google Works

Session 2 - Interview Process & General Interview Prep

Talk points:

Interview Confidence

  • Be confident, but not arrogant

Talk while you think, and code, explain everything that might be ambiguous

If running out of time and need shortcuts, explain how you would not do the shortcut in a real scenario

The interviewer is there because they want to hire someone, they are your friend not your enemy

Reading at home:

Talk points - Important advice: Pick One Language for the Interview

1: You can use a language you are comfortable in to do the coding part of the interview, but for Google, these are solid choices:

  • C++
  • Java
  • Python

You need to be very comfortable in the language, and be knowledgeable, so pick one, and do all the practice problems in that language. The more you practice the more natural it will look like you feel at developing with the language, and that's important even though knowing the syntax itself isn't. But there is a subconscious feeling we get by looking at the flow of someone working with something, and it's important to give interviewers that feeling

  1. You won't remember it all

Use methods that will improve your memory for leaning, like spaced repetition, diffusive and focus modes of thinking, and etc (the learning how to learn course on Coursera was the most helpful resource on learning I used, but I continue to learn about this). But here's some basics stuff for you to get started:

I personally don't use flash cards because I just scan my notes and upload to Drive so they are always accessible from my phone.

  1. Review, review, review

Again, though interviewers say they don't care about you memorizing details, they do want to see that you're really good at what you do, so if you easily recall the details, you will look much better.

  1. Focus

One of my struggles was trying to do too much at the same time. I not only wanted to get a job at my favorite companies, despite not going to a school where those companies would recruit, I also wanted to take a bunch of online classes on things that wouldn't help me with the interview or school, but would benefit my personal learning goals and career (such as machine learning and even stuff like philosophy and history and business). It is indeed possible to be good at all these things, but you can't do them all at once. ****Forget multi-tasking. ***** just schedule time in your calendar and focus on one thing at each time. If you can dedicate 2 hours of focused time to this guide every day, you will go a long way.

  1. Studying strategy:

For each subject covered, read and watch the content covering it, and then implement it. Please, don't skip the implementation part, this is the most important one. Do not look at AVL trees and think "Oh we covered that in my algorithms class", the interviewer will never care what your class covered, he or she will ask you to implement it.

Also, write tests to make sure the code works. Most interviewers also ask you to do that. (Or at least run through test cases, but run them on paper, not simply by plugging the input in, because on the whiteboard they want to see if you can think through the code you just wrote.

So basically the process is:

  • understand an algorithm or subject
  • implement it on paper (preferably whiteboard while talking through it as an interview)
  • test it by running through examples by hand and thinking through it
  • Implement on a computer and test with real inputs

Note: you should use standard libraries of python when practicing. Unless, for example, the question is sorting an array, then you should ask the interviewer whether he expects you to use the standard library or implement it yourself. When in doubt, always ask for clarification! Don't make assumptions, and don't be afraid to ask questions, it's a good thing.

Starting with basics: What IDE Should I use? Vim? Emacs? Eclipse?

The right answer is: the one that makes you the best. Period. Every artist and craftsman has the tools that make them the best as they can be. If that's Vim (which is for me) or Emacs, or Eclipse it's up to you. But try new stuff out. Check out some stuff about vim and emacs and you will understand how many different useful things editors can do beyond the basics:

Week 2

Session 1 - Algorithmic complexity / Big-O / Asymptotic analysis

Talk points:

  • You should be so comfortable (afte preparing and going through this) with algorithm complexity and Big-O notation that it is a natural process for you.

  • You should be able to look at algorithms and spit out what the algorithm complexity is, and as the name might suggest otherwise, it is not complex at all. In fact it is a method for quickly managing complexity while getting a good evaluation on how the algorithm will run for large-scale applications.

  • Imagine if you could do math, and simply get rid of all constants and lower order terms, and just say how the given function grows as the input grows, this is basically it.

  • Harvard CS50 - Asymptotic Notation (video)

  • Big O Notations (general quick tutorial) (video)

Home reading

Session 2 - An Overview of Data Structures and Algorithms

Talk points - Data structures

  • Here I will give a lecture on how data structures and algorithms relate to Big-O, why choosing the appropriate data structures and algorithms

  • can have a significant impact on asymptoptic complexity (Big-O). Furthermore I will make a clear distinction between algorithms and data structures,

  • and show that at the same time they work together, and that efficient algorithms make use of efficient data structures to boost performance.

  • I will focus on the big picture, giving an overview of popular and extremely useful data structures and algorithms, and in the future sessions we will dive into understanding the list of algorithms and data structures that students are expected to know.

What is a data structure - With Examples

  • A data structure is exactly what it sounds like: a structure in a computer used to store and organize data in a form that will be useful. - As you begin to think about them, you can draw on a paper to come up with a picture of how the data is organized. When doing this, don't worry about the lower levels of how computer might handle memory, or physically store it, just worry about how the data is organized. For example: an array is a data structure, and you could represent it as [3, 2, 3, 4, 5], or (4, 5, 1, 2), it doesn't matter. As you progress in computer science, you will learn that we use notations such as [] to represent data structure of certain behaviors and () for another, but when the notation is introduced then you learn about it. - We have data structures in the real world, a bookshelf is a data structure, except that the data are books. A line in front of your favorite Disney ride is a queue, where the data is people. Queues are useful to preserve the order in which the elements arrived, in computing that's a very useful concept, for many systems, ranging from simple design of systems where users might be placed on a queue to chat with an agent, or even search algorithms which we will cover later, such as breadth-first search.

Arrays

  • So why do we need anything beyond arrays? Well, if you simply want to access or update an element in the array, they are very efficient for the job and it takes constant time to do so. But imagine if you wanted to insert an element in the beginning of the array. It would take O(n) operations to do so, since we have to shift all the elements to the end by one. Video
  • Arrays (video)

List

  • If we use a list however, which is a series of items (call them nodes) connected by links, all we have to do is make the new element point to the first element of the array. If we want to insert elsewhere, it's similar, we just need to get the preceeding element and have its link point to the new element, and have the new element point to the one after the original element. And it follows that this takes O(1), whereas retrieving the Nth element takes O(N)

Video:

Queue

  • We use queues in our daily lives everywhere, in front of lines in our rollercoaster rides, medical systems, banking, finance, everywhere. And they come in all sorts of forms. The most basic takes only time in consideration, namely the first elements will be the first to be attended.

    • But there are also variations, such as priority queues, which take into consideration a series of factors. For example, in medical organ donation, we might consider the risk of death and urgency for the patient to receive a transplant (very complex system with some simplifications here, and in fact could be optimized with software).
    • The same applies to computer science, where these queues are useful for designing these systems as well as supporting algorithms such as breadth-first search, and priority queues for A* search.

    Breadth-first search basically starts with an element and considers all the elements connected to it, before going to the next level. Whereas A* search looks into factors such as the cost of moving to the node and the estimated distance reduction to the goal. Video:

Hash Tables

  • Hash Tables are beautiful things and extremely useful in a very large and diverse domain of applications. If you have seen them before, and you are under the impression that they are complicated, just forget anything you know about them. They are quite straightforward:

    • Starting with the easy part, "table", we have a data structure that represents a table mapping a value generally represented as a string, to another value of any type. That's what a table is, and if hash tables were just the running time to find a value in the table would be O(n), and it wouldn't be very useful. -> That's the power of "hashing", where we take the key which is the value that maps to another, and process it with a function (for example adding the ascii characters modulo the number of entries in the table, which works but we will later see can be optimized substantially), and finds where in the table it belongs - Know how hash tables are implemented, but more importantly know how to use them to build new systems.
    Videos:
 - [ ] [Core Hash Tables (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/m7UuP/core-hash-tables)
 - [ ] [Data Structures (video)](https://www.coursera.org/learn/data-structures/home/week/3)
 - [ ] [Phone Book Problem (video)](https://www.coursera.org/learn/data-structures/lecture/NYZZP/phone-book-problem)

Trees

  • Trees are again just another form of organizing data in a way that provides benefits for certain applications. It is called a Tree because it has branches, like real life trees do. Most think of it as an upside down tree. For example: 3 /
    5 1 /
    0 2
    • Trees come in all sorts and forms, depending on the application we are desigining them for there are advantages in choosing one type from another, and we will look at each of those indidually as well as examine the trade-offs in future sessions. But it is easy to understand the great advantage of trees at all by talking about binary search trees (BSTs). Their one rule is that:
    • For every node, its left child contains a value smaller than or equal to itself, and its right child is larger. E.g: 4 /
      2 5 /
      1 3

We can see that finding an element here only takes O(log(n)) time for a generally balanced tree. We will also looking at the problem of unbalenced trees later (where most the height of one of the children is much larger than the other, and worst case run time is O(n), to solve this we have balancing algorithms)

Videos:

Graphs

  • Graphs, just like trees, are another way to represent data. A tree is actually just a specific form of a graph. Graphs are very important when we want to model items that have a relationship with one another, like trees. Every tree is a graph, but not every graph is a tree because some graphs can contain cycles (loops) and trees cannot.

Videos:

Home reading:

Week 3

Session 1 - Recursion

Concept:

Example Application:

Binary search https://www.coursera.org/learn/object-oriented-java/lecture/Zmla4/core-binary-search

Quicksort

Home Reading:

Session 2 - Basic Algorithms examples

Talk points: Here we will see the importance of algorithms in designing efficient applications, and how we can benefit from using the advantages of efficient data structures and algorithms together to create very powerful systems.

Applications of Sorting

One of the most basic algorithms is sorting. Everyone is familiar with sorting. In real life we might have a bookshelf sorted by alphabetical order, which is useful for retrieving and finding the correct book at a later time.

There are many problems where sorting first will help to solve the problem more efficiently.

Home:

Advanced String searching & manipulations - [ ] Sedgewick - Suffix Arrays (video) - [ ] Sedgewick - Substring Search (videos) - [ ] 1. Introduction to Substring Search - [ ] 2. Brute-Force Substring Search - [ ] 3. Knuth-Morris Pratt - [ ] 4. Boyer-Moore - [ ] 5. Rabin-Karp - [ ] Search pattern in text (video)

Applications of Hash tables

Home Videos:

Week 4

Session 1 - Machine Learning - Supervised Learning

Intro:

Classification:

Session 2 - Machine Learning - Unsupervised Learning

Intro:

K-Means:

Applications:

Home Reading:

Week 5

Session 1 - Search Trees, and Balanced Trees

For interviews, definitely know the properties and implementation of binary search trees. For balanced trees, know the general advantages of each, but you will probably not be asked to straight up implement an AVL Tree. You might have to do something that uses that idea where you would more or less end up inventing it on the fly.

Home Reading:

Session 2 - Heaps, Tries and More

Some Applications of Trees:

Home Reading

Week 6

Session 1 - Graph Properties and Graph Search

Dijkstra Graph Search Algorihtm

Home Reading

Session 2 - Solving Problems Using Graphs

Use this: https://www.coursera.org/learn/algorithms-on-graphs

Home Reading

Graphs are a huge subject in computer science, there are many applications in which they are powerful. From modeling the relationships between people in social networks, to representing connections of genomic data in trying to understand patterns of diseases, they are very useful. There are many ways to represent them and we will understand them below:

Week 7

Session 1 - Dynamic Programming

Knapsack:

Optimal Substructure:

Home Reading

Dynamic programming is quite simple. It takes advantages of two things seen previously: data structures and recursion.

Session 2 - Solving Problems with Dynamic Programming

See from skiena's slides, and within the extra content here in the guide and:

Edit distance: https://www.coursera.org/learn/dna-sequencing/lecture/ZDDOH/practical-implementing-dynamic-programming-for-edit-distance TSP: https://www.coursera.org/learn/advanced-algorithms-and-complexity/lecture/71PHI/tsp-dynamic-programming

Backtracking https://www.coursera.org/learn/comparing-genomes/lecture/TDKlW/dynamic-programming-and-backtracking-pointers

Home Reading

https://www.coursera.org/learn/algorithms-greedy

Week 8

Session 1 - Bitwise operations, Discrete Mathematics, and NP Completeness and Computability

Combinatorics (n choose k) & Probability

Shortest Paths and NP, NP-Complete, and Approximation Algorithms

Home Reading

Probability:

Complexity:

Session 2 - Caches, Processes and Threads, and other topics (edit)

Bitwise operations

Bit manipulation C Programming Tutorial 2-10: Bitwise Operators (video) Binary: Plusses & Minuses (Why We Use Two's Complement) (video) 4 ways to count bits in a byte (video)

Caches

- [ ] LRU cache:
    - [ ] [The Magic of LRU Cache (100 Days of Google Dev) (video)](https://www.youtube.com/watch?v=R5ON3iwx78M)
    - [ ] [Implementing LRU (video)](https://www.youtube.com/watch?v=bq6N7Ym81iI)
    - [ ] [LeetCode - 146 LRU Cache (C++) (video)](https://www.youtube.com/watch?v=8-FZRAjR7qU)
- [ ] CPU cache:
    - [ ] [MIT 6.004 L15: The Memory Hierarchy (video)](https://www.youtube.com/watch?v=vjYF_fAZI5E&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-&index=24)
    - [ ] [MIT 6.004 L16: Cache Issues (video)](https://www.youtube.com/watch?v=ajgC3-pyGlk&index=25&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-)

Processes and Threads

Very Basics first:

Home Reading

Week 9

Session 1 - Testing and System Design

Give talk on design and testing

Home Reading

Session 2 - Putting it all together and Review

This section will have shorter videos that can you watch pretty quickly to review most of the important concepts. It's nice if you want a refresher often.

  • Wrap up

Home Reading (for your own, on your own time, don't do all this in a week otherwise you will be wasting your time since you won't remember any of it by cramming it)

Week 10 - Practice

Coding exercises/challenges

Once you've learned your brains out, put those brains to work. Take coding challenges every day, as many as you can.

Challenge sites:

Once you're closer to the interview

General Tips

Resume Tips

Interview Tips

Coding Question Practice

Now that you know all the computer science topics above, it's time to practice answering coding problems.

Coding question practice is not about memorizing answers to programming problems.

Why you need to practice doing programming problems:

  • problem recognition, and where the right data structures and algorithms fit in
  • gathering requirements for the problem
  • talking your way through the problem like you will in the interview
  • coding on a whiteboard or paper, not a computer
  • coming up with time and space complexity for your solutions
  • testing your solutions

There is a great intro for methodical, communicative problem solving in an interview. You'll get this from the programming interview books, too, but I found this outstanding:

No whiteboard at home? That's fine, buy one. Or don't if that's really an issue, but just practice on paper and practice whiteboarding skills at school or something. You should really practice on whiteboard though, to mimick the real interview setting. But the main thing you want to practice is to practice under stress, there's nothing like coding in front of a guy who is going to decide whether you get a job or not, and then you're as nervous as you've never been before.

The solution? Practice that. How? Every interview you get the opportunity in doing, do it. Even if it's a company you don't care much about, you will still be practicing coding while someone else is looking at you and your subconscious mind constantly fighting you by making you afraid of being embarassed. Trust me, I had the biggest issues with this, the only way to get over it was to interview dozens and dozens of times, just like speaking in public or anything of the sort. The more you do it, the more you realize the worst case scenario is not nearly as big of a deal as your pessimistic-self anticipates, and in that process you will become less and less nervous each time you attempt something similar.

Supplemental:

Interview Questions

Think of about 20 interview questions you'll get, along the lines of the items below. Have 2-3 answers for each. Have a story, not just data, about something you accomplished.

  • Why do you want this job?
  • What's a tough problem you've solved?
  • Biggest challenges faced?
  • Best/worst designs seen?
  • Ideas for improving an existing Google product.
  • How do you work best, as an individual and as part of a team?
  • Which of your skills or experiences would be assets in the role and why?
  • What did you most enjoy at [job x / project y]?
  • What was the biggest challenge you faced at [job x / project y]?
  • What was the hardest bug you faced at [job x / project y]?
  • What did you learn at [job x / project y]?
  • What would you have done better at [job x / project y]?

Questions for the interviewer

  • How large is your team?
  • What does your dev cycle look like? Do you do waterfall/sprints/agile?
  • Are rushes to deadlines common? Or is there flexibility?
  • How are decisions made in your team?
  • How many meetings do you have per week?
  • Do you feel your work environment helps you concentrate?
  • What are you working on?
  • What do you like about it?
  • What is the work life like?

Once You've Got The Job

Books (if you are thirsty for success please be thirsty for knowledge, reading, and learning).

About

No description, website, or topics provided.

Resources

Readme

License

CC-BY-SA-4.0 license
Activity

Stars

7 stars

Watchers

7 watching

Forks

6 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 28

+ 14 contributors