This information is to know which technical skills you should have as a junior developer.
We're trying to model either real world entities or processes and represent them in software.
An Object represents an entity and is a concept. It has:
1. Properties (attributes)
2. Behavior (methods)
A Class is a description of a group of objects with common properties (attributes) and behavior (operations).
It's an abstraction, an object is an instance of a class.
- For example:
- Class: Course
- Attributes: Name, Location, etc.
- Constructors: Name = "NameExample" (Initialize properties)
- Methods: AddStudent, DeleteStudent, GetCourses, etc.
More info:
< Back to Table of Contents >
-
Abstraction
Hiding internal details and showing functionality only. For example, I like coffee but I don't need to know how the machine is going to do coffee.
Abstraction focus on what the object does instead of how it does. It provides generalized view of classes.
More info:
-
Polymorphism
“Many shapes” - in Greek.
It's Gives a way to use a class exactly like its parent so there’s no confusion with mixing types. But each child class keeps its own methods as they are.
Polymorphism in Java are mainly of two types: (2) OOP
- Overloading in Java
- Overriding in Java
We can use the child class methods that are in common with the parent class:
Transport suzuki = new Motorcycle();
We can reference from a parent class to an object of the child class.
public static void main(String[] args){ Transport suzuki = new Motorcycle("Suzuki AB23"); Transport ford = new Van("Ford LE34"); checkTires(susuki); checkTires(ford); } public static void checkTires(Transport c){ c.tires(); } // tires method of the Motorcycle and Van classes is called.
More info:
-
Inheritance
In Java, when an "Is-A" relationship exists between two classes we use Inheritance.
The parent class is termed superclass and the inherited class is the subclass.
(For Java) - The keyword "extend, is used by the sub class to inherit the features of super class.
Inheritance is important since it leads to reusability of code.
Types:
- One class extends another class (one class only)
- One class extends another classes (multiple Inheritance)
- One class can inherit from a derived class (multilevel Inheritance)
- One class is inherited by many sub classes (Hierarchical Inheritance)
- A combination of Single and Multiple inheritance (Hybrid Inheritance)
class subClass extends superClass { //methods and fields }
More info:
-
Encapsulation
Hides variables or some implementation that may be changed so often in a class to prevent outsiders access it directly. They must access it via getter and setter methods.
More info:
< Back to Table of Contents >
Java composition is achieved by using instance variables that refers to other objects.
For example, a Person has a Job.
```java
package com.journaldev.composition;
public class Person {
//composition has-a relationship
private Job job;
public Person(){
this.job=new Job();
job.setSalary(1000L);
}
public long getSalary() {
return job.getSalary();
}
}
```
More info:
< Back to Table of Contents >
Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later.
Such as Git, Mercurial, Bazaar or Darcs; clients don’t just check out the latest snapshot of the files; rather, they fully mirror the repository, including its full history. Thus, if any server dies, and these systems were collaborating via that server, any of the client repositories can be copied back up to the server to restore it. Every clone is really a full backup of all the data. Furthermore, many of these systems deal pretty well with having several remote repositories they can work with, so you can collaborate with different groups of people in different ways simultaneously within the same project. This allows you to set up several types of workflows that aren’t possible in centralized systems, such as hierarchical models.
GitHub is a hosting service for Git repositories like GitLab and Bitbucket, where developers store their projects and network with like minded people.
Remote branch: origin/master Local branch: master
Some basic commands:
- git init
- git clone
- git branch
- git checkout
- git add .
- git status
- git logs
- git commit -m "Description"
- git stash
- git push
- git fetch
- git rebase
- git merge
GitFlow:
- Create a branch
- Clone the branch
- Develop your feature (including your tests)
- Commit changes local
- Push changes remote
- Managing conflicts (if they occurs)
- Create pull request
- Merge (if its necessary)
Fork or Clone a repository?
Forked project is just a request for GitHub to clone the project and registers it under your username.
Cloned project is where you have proper duplication, and separation between, two (possibly different) versions of a repository.
Write Good Commit Messages, for example:
- add subtle background pattern to body
- make subheadings larger on archive pages
- fix typo in site footer
- cleanup code with this tool
Tagging
Tags are pointers to a certain commit, and just an easier way to reference them than memorizing hash numbers. A common way to use tags is for version numbering. Github vill generate zip files ready for download using your tags, Thematic’s can be found at Tags. But they are not needed for this workflow, see them as an optional extra at this point.
Tip:
- git fetch + git rebase (instead git pull)
Fetch will only connect to the remote repository and download the latest commits to your history. Git rebase reapply commits on top of another base tip.
More info:
< Back to Table of Contents >
It is the process of dividing software development work into distinct phases to improve design, product management, and project management. It is also known as a software development life cycle (SDLC).
-
Agile development
- It advocates adaptive planning, evolutionary development, early delivery, and continual improvement, and it encourages rapid and flexible response to change. The values and principles espoused in this manifesto were derived from and underpin a broad range of software development frameworks, including Scrum and Kanban.
-
Waterfall development
- The waterfall model is a sequential development approach, in which development is seen as flowing steadily downwards (like a waterfall) through several phases.
-
Spiral development
- Combines some key aspects of the waterfall model and rapid prototyping methodologies, in an effort to combine advantages of top-down and bottom-up concepts. It provided emphasis in a key area many felt had been neglected by other methodologies: deliberate iterative risk analysis, particularly suited to large-scale complex systems.
-
Offshore development
- It aims at dispatching the software development process over various geographical areas to optimize project spending by capitalizing on countries with lower salaries and operating costs. Geographically distributed teams can be integrated at any point in the software development process through custom hybrid models.
-
Other
- Behavior-driven development and business process management.
- Chaos model - The main rule always resolves the most important issue first.
- Incremental funding methodology - an iterative approach.
- Lightweight methodology - a general term for methods that only have a few rules and practices.
- Structured systems analysis and design method - a specific version of the waterfall.
- Slow programming, as part of the larger Slow Movement, emphasizes careful and gradual work without (or minimal) time pressures. Slow programming aims to avoid bugs and overly quick release schedules.
- V-Model (software development) - an extension of the waterfall model.
- Unified Process (UP) is an iterative software development methodology framework, based on Unified Modeling Language (UML).
More info:
< Back to Table of Contents >
- Architecture First
- Optimization VS Readability. Fuck the optimization
- Test Coverage
- Keep It Simple
- Comments
- Hard Coupled VS Less Coupled
- Code Reviews
- Don't Write All At Once - Make Developing Iterative.
- Automation / Manual
- Consistent Indentation
- Avoid Obvious Comments
- Code Grouping
- Consistent Naming Scheme
- Dry Principle
- Limit Line Length
- File and Folder Organization
- Consistent Temporary Names
- Capitalize SQL Special Words
- Separation of Code and Data
- Consider Alternate Syntax Inside Templates
- Read Open Source Code
- Code Refactoring
More info:
< Back to Table of Contents >
Test the positive and negative functionality of your code.
- Test Driven Development:
It is an evolutionary approach to development which combines test-first development where you write a test before you write just enough production code to fulfill that test and refactoring.
Types of testing:
- Unit Testing
- It focuses on smallest unit of software design. In this we test an individual unit or group of inter related units. It is often done by programmer by using sample input and observing its corresponding outputs.
- Integration Testing
- The objective is to take unit tested components and build a program structure that has been dictated by design.Integration testing is testing in which a group of components are combined to produce output.
- Regression Testing
- Every time new module is added leads to changes in program. This type of testing make sure that whole component works properly even after adding components to the complete program.
More info:
< Back to Table of Contents >
There are many situations where you need to notify an error to the client that is using whatever you design.
You could need to tell that client that:
- He doesn't have enough privileges for that operation.
- He doesn't have access to that resource.
- The item he was trying to access doesn't exist.
- etc.
In these cases, you would normally return an HTTP Code Status in the range of 400 (from 400 to 499).
Also, you could have a look for 5xx status codes.
More info:
< Back to Table of Contents >
In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern isn't a finished design that can be transformed directly into code. It is a description or template for how to solve a problem.
- Creational Design Patterns
- Structural Design Patterns
- Behavioral Design Patterns
- Miscellaneous Design Patterns
- MVC
- Dependency Injection Pattern
- DAO Design Pattern
More info:
< Back to Table of Contents >
API
It is a piece of software that plugs one application directly into the data and services of another by granting it access to specific parts of a server. APIs let two pieces of software communicate, they’re the basis for everything we do on mobile, and they allow us to streamline IT architectures, power savvier marketing efforts, and make easier to share data sets.
REST APIs are stateless, meaning that calls can be made independently of one another, and each call contains all of the data necessary to complete itself successfully.
REST or RESTful API design (Representational State Transfer) is designed to take advantage of existing protocols. While REST can be used over nearly any protocol, it usually takes advantage of HTTP when used for Web APIs. This means that developers do not need to install libraries or additional software in order to take advantage of a REST API design.
A RESTful API is an application program interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data.
A RESTful API -- also referred to as a RESTful web service -- is based on representational state transfer (REST) technology, an architectural style and approach to communications often used in web services development.
HTTP METHODS
Also, don't forget document your API:
More info:
< Back to Table of Contents >
SOAP (Simple Object Access Protocol) is its own protocol, and is a bit more complex by defining more standards than REST—things like security and how messages are sent. These built-in standards do carry a bit more overhead, but can be a deciding factor for organizations that require more comprehensive features in the way of security, transactions, and ACID (Atomicity, Consistency, Isolation, Durability) compliance. For the sake of this comparison, we should point out that many of the reasons SOAP is a good choice rarely apply to web services scenarios, which make it more ideal for enterprise-type situations.
Reasons you may want to build an application with a SOAP API include higher levels of security (e.g., a mobile application interfacing with a bank), messaging apps that need reliable communication, or ACID compliance.
More info:
< Back to Table of Contents >
Type
- SQL databases are primarily called as Relational Databases (RDBMS); whereas NoSQL database are primarily called as non-relational or distributed database.
The difference speaks to how they’re built, the type of information they store, and how they store it. Relational databases are structured, like phone books that store phone numbers and addresses.
Non-relational databases are document-oriented and distributed, like file folders that hold everything from a person’s address and phone number to their Facebook likes and online shopping preferences.
SQL VS noSQL
-
Structured Query Language (SQL) is a programming language used by database architects to design relational databases. In an SQL database like MySQL, Sybase, Oracle, or IBM DM2, SQL executes queries, retrieves data, and edits data by updating, deleting, or creating new records. SQL is a lightweight, declarative language that does a lot of heavy lifting for the relational database, acting like a database’s version of a server-side script. One particular advantage of SQL is its simple-yet-powerful JOIN clause, which allows developers to retrieve related data stored across multiple tables with a single command.
-
Reasons to use a SQL database:
- You need to ensure ACID (Atomicity, Consistency, Isolation, Durability) compliancy.
- Your data is structured and unchanging.
-
Reasons to use noSQL database:
- Storing large volumes of data that often have little to no structure.
- Making the most of cloud computing and storage.
- Rapid development.
How do NoSQL databases work? Instead of tables, NoSQL databases are document-oriented. This way, non-structured data (such as articles, photos, social media data, videos, or content within a blog post) can be stored in a single document that can be easily found but isn’t necessarily categorized into fields like a relational database does. It’s more intuitive, but note that storing data in bulk like this requires extra processing effort and more storage than highly organized SQL data.
NoSQL databases offer another major advantage, particularly to app developers: ease of access. Relational databases have a fraught relationship with applications written in object-oriented programming languages like Java, PHP, and Python. NoSQL databases are often able to sidestep this problem through APIs, which allow developers to execute queries without having to learn SQL or understand the underlying architecture of their database system.
More info:
< Back to Table of Contents >
Most of the current technologies will improve and change over the years, but there are some techniques, tools, methodologies, etc that are going to be the sample to create a better one.
< Back to Table of Contents >