diff --git a/bike-shop/src/stage1-literals.js b/bike-shop/src/stage1-literals.js
index c749dd2..e02ed56 100644
--- a/bike-shop/src/stage1-literals.js
+++ b/bike-shop/src/stage1-literals.js
@@ -1,5 +1,20 @@
 const myBike = {
-  // your code here
-}
+  name : 'Roadster',
+  price : 199.99,
+  frame : {
+    color : 'blue',
+    height: 55,
+    style : 'cruiser'
+          },
+  brakes : {
+    back : true,
+    front : false
+  },
+  tires : {
+    diameter : 22,
+    type : 'fat'
+  },
+  rings : [2, 5]
+};
 
-module.exports = myBike
+module.exports = myBike;
diff --git a/bike-shop/src/stage2-constructors.js b/bike-shop/src/stage2-constructors.js
index c422386..73ee50b 100644
--- a/bike-shop/src/stage2-constructors.js
+++ b/bike-shop/src/stage2-constructors.js
@@ -1,17 +1,47 @@
-function Bike() {
-  // your code here
+function Bike(name, price) {
+  this.name = name;
+  this.price = price;
+  this.rings = [3, 7];
+  this.brakes = {
+    back : true,
+    front : true
+  },
+  this.tires = [new Tire, new Tire];
+  this.frame = new Frame;
 }
 
-function Frame() {
-  // your code here
+function Frame(color, size, style) {
+  this.color = color ? color : 'black';
+  this.size = size ? size : 55;
+  this.style = style ? style : 'street';
 }
 
-function Tire() {
-  // your code here
+function Tire(diameter, type) {
+  this.diameter = diameter ? diameter : 22;
+  this.type = type ? type : 'street';
+  this.rings = [2, 5];
 }
 
+
 module.exports = {
   Bike: Bike,
   Frame: Frame,
   Tire: Tire
-}
+};
+
+
+
+
+const myFrame = new Frame();
+//myFrame.color = 'black'
+//myFrame.size = 55
+//myFrame.style = 'street'
+
+const myBike = new Bike();
+//myBike.name = ''
+//myBike.price = ''
+//myBike.tires = ['front', 'back']
+
+const myTire = new Tire();
+//myTire.diameter = ''
+//myTire.type = ''
diff --git a/bike-shop/src/stage3-methods.js b/bike-shop/src/stage3-methods.js
index c422386..62f055f 100644
--- a/bike-shop/src/stage3-methods.js
+++ b/bike-shop/src/stage3-methods.js
@@ -1,5 +1,14 @@
 function Bike() {
-  // your code here
+
+  this.rings = [3, 7];
+  this.brakes = {
+    back : true,
+    front : true
+  },
+  this.tires = [new Tire, new Tire],
+  this.frame = new Frame,
+
+  this._isMoving = false;
 }
 
 function Frame() {
@@ -7,11 +16,52 @@ function Frame() {
 }
 
 function Tire() {
-  // your code here
+    this._isFlat = false;
 }
 
+
+
+
+Tire.prototype.isFlat = function () {
+  return this._isFlat;
+};
+
+Tire.prototype.puncture = function () {
+  this._isFlat = true;
+};
+
+
+Tire.prototype.repair = function () {
+  this._isFlat = false;
+};
+
+Bike.prototype.isMoving = function () {
+  return this._isMoving;
+};
+
+Bike.prototype.pedal = function () {
+  if (this.tires[0]._isFlat === true) {
+      throw "Can't pedal with a flat tire";
+  }else {
+    this._isMoving = true;
+  }
+};
+
+Bike.prototype.brake = function () {
+  this._isMoving = false;
+};
+
+Bike.prototype.gearSpeeds = function () {
+  return  this.rings[0] * this.rings[1];
+};
+
+
+
+const myTire = new Tire();
+const myBike = new Bike();
+
 module.exports = {
   Bike: Bike,
   Frame: Frame,
   Tire: Tire
-}
+};
diff --git a/bike-shop/src/stage4-inheritance.js b/bike-shop/src/stage4-inheritance.js
index 2281fd5..ccb5e6c 100644
--- a/bike-shop/src/stage4-inheritance.js
+++ b/bike-shop/src/stage4-inheritance.js
@@ -3,14 +3,70 @@ class Frame {
 }
 
 class Tire {
-  // your code here
+
 }
 
 class Bike {
-  // your code here
+  constructor() {
+    this.tires = [new Tire, new Tire];
+    this.frame = new Frame;
+    this.brakes = {
+      back : true,
+      front : true
+    };
+    this.rings = [3, 7]
+  };
+}
+
+class MountainBike extends Bike {
+  constructor() {
+  super();
+  this.tires[0].type = 'dirt';
+  this.tires[1].type = 'dirt';
+  this.frame.style = 'mountain';
+  this.shocks = 20;
+  }
+  adjustShocks(newSagSetting){
+    this.shocks = newSagSetting;
+  }
+}
+
+class BMXBike extends Bike {
+  constructor() {
+  super();
+  this.brakes.front = false;
+  this.tires[0].diameter = 20;
+  this.tires[1].diameter = 20;
+  }
+}
+
+class RacingBike extends Bike {
+  constructor() {
+  super();
+  this.tires[0].type = 'road';
+  this.tires[1].type = 'road';
+  this.frame.style = 'racing';
+  //work on this below
+  this.rings[0] = 3;
+  this.rings[1] = 10;
+  }
+  gearSpeeds(){
+    return this.rings[0] * this.rings[1];
+  }
 }
 
+
+
+let mountainBike = new MountainBike();
+let bmxBike = new BMXBike();
+let racingBike = new RacingBike();
+let bike = new Bike();
+
+
+
 module.exports = {
   Bike: Bike,
-  // you'll need to export new classes here
-}
+  MountainBike: MountainBike,
+  BMXBike: BMXBike,
+  RacingBike: RacingBike
+};
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..9ab7b0f
--- /dev/null
+++ b/index.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title></title>
+  </head>
+  <body>
+    <script src="music-player/songNew.js"></script>
+    <script src="music-player/albumNew.js"></script>
+    <script src="music-player/artistNew.js"></script>
+    <script src="music-player/playlistNew.js"></script>
+    <script src="music-player/playerNew.js"></script>
+  </body>
+</html>
diff --git a/jsinfo/chaining.js b/jsinfo/chaining.js
new file mode 100644
index 0000000..4a7e52d
--- /dev/null
+++ b/jsinfo/chaining.js
@@ -0,0 +1,45 @@
+// There’s a ladder object that allows to go up and down
+/*
+let ladder = {
+  step: 0,
+  up() {
+    this.step++;
+    return this;
+  },
+  down() {
+    this.step--;
+    return this;
+
+  },
+  showStep: function() { // shows the current step
+    alert( this.step );
+    return this;
+
+  }
+};
+
+we need to make several calls in sequence, can do it like this:
+ladder.up();
+ladder.up();
+ladder.down();
+ladder.showStep(); // 1
+*/
+
+//rewrite the code to make it chainable
+let ladder = {
+  step: 0,
+  up() {
+    this.step++;
+    return this;
+  },
+  down() {
+    this.step--;
+    return this;
+  },
+  // shows the current step
+  showStep: function() {
+    alert( this.step );
+    return this;
+  }
+};
+ladder.up().up().down().showStep(); // 1
diff --git a/jsinfo/createACalc.js b/jsinfo/createACalc.js
new file mode 100644
index 0000000..17e1698
--- /dev/null
+++ b/jsinfo/createACalc.js
@@ -0,0 +1,21 @@
+// Create an object calculator with three methods: read , sum, mul
+
+let calculator = {
+   read() {
+  // get values
+      this.value1 = parseFloat(prompt('what is the first value'));
+      this.value2 = parseFloat(prompt('what is the second value'));
+  },
+
+  sum() {
+    return this.value1 + this.value2;
+  },
+
+  mul() {
+    return this.value1 * this.value2;
+  }
+};
+
+calculator.read();
+alert( calculator.sum() );
+alert( calculator.mul() );
diff --git a/jsinfo/createNewAccumlator.js b/jsinfo/createNewAccumlator.js
new file mode 100644
index 0000000..fd56bca
--- /dev/null
+++ b/jsinfo/createNewAccumlator.js
@@ -0,0 +1,25 @@
+/*Create a constructor function Accumulator(startingValue).
+
+Object that it creates should:
+
+Store the “current value” in the property value. The starting value is set to the argument of the constructor startingValue.
+The read() method should use prompt to read a new number and add it to value.
+In other words, the value property is the sum of all user-entered values with the initial value startingValue.
+*/
+
+
+function Accumulator(startingValue) {
+  //holds the startingValue to be minipulated
+  this.value = startingValue;
+
+  this.read = function () {
+    //adds the prompted amount to the value at the moment
+    this.value += parseFloat(prompt('what is the first value'));
+  };
+}
+
+
+let accumulator = new Accumulator(1); // initial value 1
+accumulator.read(); // adds the user-entered value
+accumulator.read(); // adds the user-entered value
+alert(accumulator.value); // shows the sum of these values
diff --git a/jsinfo/createNewCalc.js b/jsinfo/createNewCalc.js
new file mode 100644
index 0000000..d2c871f
--- /dev/null
+++ b/jsinfo/createNewCalc.js
@@ -0,0 +1,30 @@
+/*Create a constructor function Calculator
+that creates objects with 3 methods:
+read() sum() mul() */
+
+function Calculator() {
+
+  this.read = function () {
+    // get values
+    this.value1 = parseFloat(prompt('what is the first value'));
+    this.value2 = parseFloat(prompt('what is the second value'));
+  };
+
+  this.sum = function () {
+    this.sumResults = this.value1 + this.value2;
+    return this.sumResults;
+  };
+
+  this.mul = function () {
+    this.mulResults = this.value1 * this.value2;
+    return this.mulResults;
+  };
+
+}
+
+let calculator = new Calculator();
+
+calculator.read();
+
+alert( 'Sum=' + calculator.sum() );
+alert( 'Mul=' + calculator.mul() );
diff --git a/jsinfo/errorCreatingAnInstance.js b/jsinfo/errorCreatingAnInstance.js
new file mode 100644
index 0000000..596a6e9
--- /dev/null
+++ b/jsinfo/errorCreatingAnInstance.js
@@ -0,0 +1,26 @@
+/*
+Here’s the code with Rabbit extending Animal.
+
+Unfortunately, Rabbit objects can’t be created.
+What’s wrong? Fix it.
+*/
+class Animal {
+
+  constructor(name) {
+    this.name = name;
+  }
+
+}
+
+class Rabbit extends Animal {
+  constructor(name) {
+    //need to add a supper function to allow inheritance
+    super(name);
+    //now with the super()
+    //this.name = name;
+    this.created = Date.now();
+  }
+}
+
+let rabbit = new Rabbit('White Rabbit'); // Error: this is not defined
+alert(rabbit.name);
diff --git a/jsinfo/errorInInheritance.js b/jsinfo/errorInInheritance.js
new file mode 100644
index 0000000..c8e8958
--- /dev/null
+++ b/jsinfo/errorInInheritance.js
@@ -0,0 +1,27 @@
+/*
+Find an error in the prototypal inheritance below.
+What’s wrong? What are consequences going to be?
+*/
+
+function Animal(name) {
+  this.name = name;
+}
+
+Animal.prototype.walk = function() {
+  alert(this.name + ' walks');
+};
+
+function Rabbit(name) {
+  this.name = name;
+}
+
+//Error it will overwrite all of Rabbit's prototype to Animal's
+Rabbit.prototype = Animal.prototype;
+
+//This will overwrite the previous walk prototype and animals will now bounce and not walk
+Rabbit.prototype.walk = function() {
+  alert(this.name + ' bounces!');
+};
+
+let rabbit = new Rabbit;
+let animal = new Animal('skunk');
diff --git a/jsinfo/extendClock.js b/jsinfo/extendClock.js
new file mode 100644
index 0000000..17b1cf8
--- /dev/null
+++ b/jsinfo/extendClock.js
@@ -0,0 +1,66 @@
+class Clock {
+  // ({ ... }) allows the item to be passed in as a object literal
+  constructor({template}){
+  this._template = template;
+  }
+// prototype not allowed in classes. bound to the class function
+  _render() {
+    let date = new Date();
+
+    let hours = date.getHours();
+    if (hours < 10) hours = '0' + hours;
+
+    let mins = date.getMinutes();
+    if (mins < 10) min = '0' + mins;
+
+    let secs = date.getSeconds();
+    if (secs < 10) secs = '0' + secs;
+
+    let output = this._template
+      .replace('h', hours)
+      .replace('m', mins)
+      .replace('s', secs);
+
+    console.log(output);
+  }
+
+//clock.stop() will stop the clock
+  stop() {
+    clearInterval(this._timer);
+    console.log('clocked stopped');
+  };
+
+//clock.start() would then restart the clock
+  start() {
+    this._render();
+    //setInterval(function, milliseconds, param1, param2, ...)
+    this._timer = setInterval(() => this._render(), this._precision);
+
+    //this._timer = setInterval(this._render, this._precision);
+
+    var myfunc = () => this._render();
+    setInterval(myfunc, 5000);
+
+    this._timer = setInterval(function() {
+      return this._render();
+    }, this._precision);
+  }
+}
+
+// pass inheritence from Clock to ExtendedClock
+class ExtendedClock extends Clock {
+
+  constructor(val) {
+    //allows for the inheritence to be manipulated
+    super(val);
+    //set the variable
+    let {precision=1000} = val;
+    this._precision = precision;
+  }
+}
+
+let clock = new ExtendedClock({
+  template: 'h:m:s',
+  precision: 1000
+});
+    clock.start();
diff --git a/jsinfo/extendableCalculator.js b/jsinfo/extendableCalculator.js
new file mode 100644
index 0000000..0962ef7
--- /dev/null
+++ b/jsinfo/extendableCalculator.js
@@ -0,0 +1,42 @@
+//Create a calculator that can take a string and return the value
+function Calculator() {
+
+//holds new method funtions
+  let methods = {
+    '+' : function(value1, value2){
+      return parseFloat(value1) + parseFloat(value2);
+    },
+    //arrow function
+    '-' : (value1, value2) => parseFloat(value1) - parseFloat(value2),
+  };
+
+  this.calculate = function (str) {
+
+    let strSplit = str.split(' ');
+    var value1 = strSplit[0];
+    var value2 = strSplit[2];
+    var operator = strSplit[1];
+
+//return the value of the string to be operated on
+    return methods[operator](value1, value2);
+  };
+
+  this.addOperator =function (name, func){
+  methods[name] = func;
+};
+}
+
+let calc = new Calculator;
+
+alert( calc.calculate('3 + 7') ); // 10
+
+let newCalc = new Calculator;
+
+newCalc.addOperator('*', (a, b) => a * b);
+newCalc.addOperator('/', (a, b) => a / b);
+newCalc.addOperator('**', (a, b) => a ** b)
+newCalc.addOperator('pie', (a,b) => 'I have ' + a + ' pies cut into ' + b + ' slices each');
+alert(newCalc.calculate('2 * 3'));  //6
+alert(newCalc.calculate('2 ** 3')); //8
+alert(newCalc.calculate('6 / 2')); //3
+alert(newCalc.calculate('7 pie 4'));
diff --git a/jsinfo/helloObject.js b/jsinfo/helloObject.js
new file mode 100644
index 0000000..054b976
--- /dev/null
+++ b/jsinfo/helloObject.js
@@ -0,0 +1,15 @@
+//Hello, object
+
+//Creating an object
+
+
+
+let user = {
+  name : 'John',
+  surname : 'Smith'
+};
+// reassign name to 'Pete'
+
+user.name = 'Pete';
+// Delete the property of name
+delete user.name;
diff --git a/jsinfo/multiplyNumericByTwo.js b/jsinfo/multiplyNumericByTwo.js
new file mode 100644
index 0000000..08c5a6b
--- /dev/null
+++ b/jsinfo/multiplyNumericByTwo.js
@@ -0,0 +1,23 @@
+/* Create a function multiplyNumeric(obj) that multiplies
+ all numeric properties of obj by 2.*/
+
+ function multiplyNumeric(obj) {
+   //gets values of the keys in the object
+   for (let key in obj) {
+     /*makes sure that the type of is number
+     so you can actually multiply by two*/
+     if (typeof obj[key] === 'number') {
+            obj[key] *= 2;
+     }
+   }
+ }
+
+//example object
+ let menu = {
+   width: 200,
+   height: 300,
+   title: 'My menu'
+ };
+
+//call the function
+ multiplyNumeric(menu);
diff --git a/jsinfo/rewritePrototype.js b/jsinfo/rewritePrototype.js
new file mode 100644
index 0000000..6197c66
--- /dev/null
+++ b/jsinfo/rewritePrototype.js
@@ -0,0 +1,79 @@
+//The Clock class is written in functional style. Rewrite it using prototypes.
+
+/*rewrite this
+function Clock({ template }) {
+
+  let timer;
+
+  function render() {
+    let date = new Date();
+
+    let hours = date.getHours();
+    if (hours < 10) hours = '0' + hours;
+
+    let mins = date.getMinutes();
+    if (mins < 10) min = '0' + mins;
+
+    let secs = date.getSeconds();
+    if (secs < 10) secs = '0' + secs;
+
+    let output = template
+      .replace('h', hours)
+      .replace('m', mins)
+      .replace('s', secs);
+
+    console.log(output);
+  }
+
+  this.stop = function() {
+    clearInterval(timer);
+  };
+
+  this.start = function() {
+    render();
+    timer = setInterval(render, 1000);
+  };
+
+}
+
+let clock = new Clock({template: 'h:m:s'});
+   clock.start();
+   */
+
+function Clock({ template }) {
+  this.template = template;
+}
+
+Clock.prototype.render = function(){
+  let date = new Date();
+
+  let hours = date.getHours();
+  if (hours < 10) hours = '0' + hours;
+
+  let mins = date.getMinutes();
+  if (mins < 10) min = '0' + mins;
+
+  let secs = date.getSeconds();
+  if (secs < 10) secs = '0' + secs;
+
+  let output = this.template
+    .replace('h', hours)
+    .replace('m', mins)
+    .replace('s', secs);
+
+  console.log(output);
+};
+
+Clock.prototype.stop = function() {
+  clearInterval(this.timer);
+};
+
+Clock.prototype.start = function() {
+  this._render();
+  this.timer = setInterval(() =>this._render(), 1000);
+};
+
+
+
+let clock = new Clock({template: 'h:m:s'});
+  clock.start();
diff --git a/jsinfo/rewriteToClass.js b/jsinfo/rewriteToClass.js
new file mode 100644
index 0000000..6b90ea3
--- /dev/null
+++ b/jsinfo/rewriteToClass.js
@@ -0,0 +1,82 @@
+//Rewrite the Clock class from prototypes to the modern “class” syntax.
+
+/*rewrite this
+function Clock({ template }) {
+  this._template = template;
+}
+
+Clock.prototype._render = function() {
+  let date = new Date();
+
+  let hours = date.getHours();
+  if (hours < 10) hours = '0' + hours;
+
+  let mins = date.getMinutes();
+  if (mins < 10) min = '0' + mins;
+
+  let secs = date.getSeconds();
+  if (secs < 10) secs = '0' + secs;
+
+  let output = this._template
+    .replace('h', hours)
+    .replace('m', mins)
+    .replace('s', secs);
+
+  console.log(output);
+};
+
+Clock.prototype.stop = function() {
+  clearInterval(this._timer);
+};
+
+Clock.prototype.start = function() {
+  this._render();
+  this._timer = setInterval(() => this._render(), 1000);
+};
+
+let clock = new Clock({template: 'h:m:s'});
+    clock.start();
+*/
+
+class Clock {
+  // ({ ... }) allows the item to be passed in as a object literal
+  constructor({template}){
+    //wanted to check what type of
+    console.log(typeof({template}));
+  this._template = template;
+  }
+// prototype not allowed in classes. bound to the class function
+  _render() {
+    let date = new Date();
+
+    let hours = date.getHours();
+    if (hours < 10) hours = '0' + hours;
+
+    let mins = date.getMinutes();
+    if (mins < 10) min = '0' + mins;
+
+    let secs = date.getSeconds();
+    if (secs < 10) secs = '0' + secs;
+
+    let output = this._template
+      .replace('h', hours)
+      .replace('m', mins)
+      .replace('s', secs);
+
+    console.log(output);
+  }
+
+//clock.stop() will stop the clock
+  stop() {
+    clearInterval(this._timer);
+  }
+
+//clock.start() would then restart the clock
+  start() {
+    this._render();
+    this._timer = setInterval(() => this._render(), 1000);
+  }
+}
+
+let clock = new Clock({template: 'h:m:s'});
+    clock.start();
diff --git a/jsinfo/searchingAlgo.js b/jsinfo/searchingAlgo.js
new file mode 100644
index 0000000..7e9c08b
--- /dev/null
+++ b/jsinfo/searchingAlgo.js
@@ -0,0 +1,31 @@
+/*
+Use __proto__ to assign prototypes in a way that any property
+lookup will follow the path: pockets → bed → table → head. For instance,
+pockets.pen should be 3 (found in table), and bed.glasses should be 1 (found in head).
+*/
+
+let head = {
+  glasses: 1
+};
+
+let table = {
+  pen: 3,
+  __proto__ : head
+};
+
+let bed = {
+  sheet: 1,
+  pillow: 2,
+  __proto__ : table
+};
+
+let pockets = {
+  money: 2000,
+  __proto__ : bed
+};
+
+ /*is it faster to get glasses as pocket.glasses
+ or head.glasses? Benchmark if needed.*/
+
+//It seems that pocket.glasses and head.glasses
+//take about the same amout of time
diff --git a/jsinfo/twoHamsters.js b/jsinfo/twoHamsters.js
new file mode 100644
index 0000000..0a6509a
--- /dev/null
+++ b/jsinfo/twoHamsters.js
@@ -0,0 +1,30 @@
+/*We have two hamsters: speedy and lazy inheriting from the general hamster object.
+When we feed one of them, the other one is also full. Why? How to fix it?
+*/
+
+ let hamster = {
+  stomach: [],
+
+  eat(food) {
+    //this adds apple to the hamster constructor function
+    //this.stomach.push(food)
+
+    //This adds apple to the stomach of the hamster object that called the method
+    this.stomach = [food];
+  }
+};
+
+let speedy = {
+  __proto__: hamster
+};
+
+let lazy = {
+  __proto__: hamster
+};
+
+// This one found the food
+speedy.eat('apple');
+alert( speedy.stomach ); // apple
+
+// This one also has it, why? fix please.
+alert( lazy.stomach ); // apple
diff --git a/music-player/album.js b/music-player/album.js
index 877a3aa..972902e 100644
--- a/music-player/album.js
+++ b/music-player/album.js
@@ -1 +1,21 @@
-// Your code here
+//const Song = require ('./song.js')
+
+class Album {
+
+  constructor(album){
+
+    this.artist = album[0].artist;
+    this.title = album[0].album;
+    this.genre = album[0].genre;
+    this.tracks = album;
+    this.songCount = Physical_Graffiti.length;
+  }
+}
+
+let newAlbum = new Album(Physical_Graffiti);
+
+//Artist name
+let LedZeppelin = [['Jimmy Page', 'John Bonham', 'Robert Plant', 'John Paul Jones']];
+
+LedZeppelin.push(new Album (Physical_Graffiti));
+LedZeppelin.push(new Album (Physical_Graffiti1));
diff --git a/music-player/albumNew.js b/music-player/albumNew.js
new file mode 100644
index 0000000..0d3565b
--- /dev/null
+++ b/music-player/albumNew.js
@@ -0,0 +1,23 @@
+//const Song = require ('./song.js')
+
+class Album {
+//deconstruct object
+  constructor({artist, title, genre, songs, numOfTracks}){
+
+    this.artist = artist
+    this.title = title;
+    this.genre = genre;
+    this.songs = songs;
+    this.numOfTracks = numOfTracks;
+    //check later
+    this.songCount = songs.length
+  }
+}
+
+// albumObj ={
+//   artist:
+//   title:
+//   genre:
+//   songs: []
+//   numOfTracks:
+// }
diff --git a/music-player/artist.js b/music-player/artist.js
index 877a3aa..f13950e 100644
--- a/music-player/artist.js
+++ b/music-player/artist.js
@@ -1 +1,18 @@
-// Your code here
+class Artist{
+
+  constructor(artist){
+    console.log(artist);
+    this.artist = artist[1].artist;
+    this.bandMembers = artist[0];
+    this.genre = artist[1].genre;
+    this.albums = artist.splice(1,artist.length-1);
+
+
+  }
+}
+
+let newArtist = new Artist(LedZeppelin);
+
+//PlayList
+let LedZeppelinPL = [];
+LedZeppelinPL.push(new Artist(LedZeppelin));
diff --git a/music-player/artistNew.js b/music-player/artistNew.js
new file mode 100644
index 0000000..d00dc0b
--- /dev/null
+++ b/music-player/artistNew.js
@@ -0,0 +1,14 @@
+class Artist{
+
+  constructor(artist){
+    this.name = artist.name;
+    this.bandMembers = artist.bandMembers;
+    this.genre = artist.genre;
+  }
+}
+
+// artistObj= {
+//   name:
+//   bandMembers:
+//   genre:
+// }
diff --git a/music-player/playerNew.js b/music-player/playerNew.js
new file mode 100644
index 0000000..a04a03d
--- /dev/null
+++ b/music-player/playerNew.js
@@ -0,0 +1,57 @@
+class Player {
+  constructor(name){
+    this.name = name
+    //we changed check back
+    this.songs = [];
+
+  }
+}
+
+//Artist
+let lZep = {
+  name: 'Led Zeppelin',
+  bandMembers: ['Jimmy Page', 'John Bonham', 'Robert Plant', 'John Paul Jones'],
+  genre: 'Rock'
+};
+
+const ledZep = new Artist(lZep);
+
+//Album
+let ledZepAlb ={
+  artist: 'Led Zeppelin',
+  title: 'Physical Graffiti',
+  genre: 'rock',
+  songs: [],
+  numOfTracks: 2
+};
+
+const phyGra = new Album(ledZepAlb);
+
+//Songs
+
+let kashmirLedZ = {
+  title: 'Kashmir',
+  songLength: 510,
+  album: 'Physical Graffiti',
+  artist: 'Led Zeppelin',
+  track: 6,
+  genre: 'Rock'
+};
+
+let custardPieLedZ = {
+  title: 'Custard Pie',
+  songLength: 260,
+  album: 'Physical Graffiti',
+  artist: 'Led Zeppelin',
+  track: 1,
+  genre: 'Rock'
+};
+
+phyGra.songs = [
+  new Song(kashmirLedZ),
+  new Song(custardPieLedZ)
+];
+
+//PlayerList
+
+let newPlayList = new PlayList("Our Play List");
diff --git a/music-player/playlist.js b/music-player/playlist.js
index 877a3aa..d470945 100644
--- a/music-player/playlist.js
+++ b/music-player/playlist.js
@@ -1 +1,38 @@
-// Your code here
+//inherit from song
+
+class PlayList {
+
+  constructor(name){
+    console.log(name);
+    this.playListName = 'My Play List';
+
+    this.songListArr = [];
+  }
+
+  addSong( ) {
+    this.songListArr.push('some song');
+    console.log(this.songListArr);
+    console.log('Song Added ');
+  }
+
+  removeSong ( ){
+    let findSong = this.songListArr.indexOf('some song');
+    this.songListArr.splice(findSong, 1);
+    console.log(this.title + ' has been removed');
+  }
+
+  currentSong(){
+    console.log(this.songListArr[0]);
+  }
+
+  Play( ) {
+      this._isPlaying = true;
+      console.log('I am playing a song ' + this.title);
+  }
+
+  Pause ( ){
+      this._isPlaying = false;
+      console.log(this.title + ' is now paused');
+  }
+}
+ let newPlayList = new PlayList(newArtist);
diff --git a/music-player/playlistNew.js b/music-player/playlistNew.js
new file mode 100644
index 0000000..8119ea5
--- /dev/null
+++ b/music-player/playlistNew.js
@@ -0,0 +1,40 @@
+//inherit from song
+
+class PlayList {
+
+  constructor(name){
+    this.playListName = name;
+    this.songListArr = [];
+    this._listLength = 0
+  }
+
+  addSong(song) {
+    this.songListArr.push(song);
+
+    console.log('Song Added ' + song.title);
+  }
+
+  removeSong (song){
+    for (var i = 0; i < this.songListArr.length; i++) {
+      if (this.songListArr[i].title === song) {
+        console.log(this.songListArr[i].title + ' has been removed');
+        this.songListArr.splice(i, 1);
+        break;
+      };
+    };
+  }
+
+  currentSong(){
+    console.log("Information about current song " + this.songListArr[0]);
+  }
+
+  play( ) {
+      this._isPlaying = true;
+      console.log('I am playing a song ' + this.songListArr[0].title);
+  }
+
+  pause ( ){
+      this._isPlaying = false;
+      console.log(this.songListArr[0].title + ' is now paused');
+  }
+}
diff --git a/music-player/song.js b/music-player/song.js
index 877a3aa..27079c4 100644
--- a/music-player/song.js
+++ b/music-player/song.js
@@ -1 +1,71 @@
-// Your code here
+class Song {
+
+  constructor(song){
+
+
+    this.title = song.title;
+    //in seconds
+    this.songLength = song.songLength;
+    this.album  = song.album;
+    this.artist = song.artist;
+    this.track = song.track;
+    this.genre = song.genre;
+    this._isPlaying = false;
+  }
+
+  Play( ) {
+      this._isPlaying = true;
+      console.log('I am playing a song ' + this.title);
+  }
+
+  Pause ( ){
+      this._isPlaying = false;
+      console.log(this.title + ' is now paused');
+  }
+}
+
+let kashmirLedZ = {
+  title: 'Kashmir',
+  songLength: 510,
+  album: 'Physical Graffiti',
+  artist: 'Led Zeppelin',
+  track: 6,
+  genre: 'Rock'
+};
+
+let custardPieLedZ = {
+  title: 'Custard Pie',
+  songLength: 260,
+  album: 'Physical Graffiti',
+  artist: 'Led Zeppelin',
+  track: 1,
+  genre: 'Rock'
+};
+
+
+//Album name
+let Physical_Graffiti = [];
+
+Physical_Graffiti.push(new Song (custardPieLedZ));
+Physical_Graffiti.push(new Song (kashmirLedZ));
+
+let Physical_Graffiti1 = [];
+
+Physical_Graffiti1.push(new Song (custardPieLedZ));
+Physical_Graffiti1.push(new Song (kashmirLedZ));
+
+//Song name
+let newSong = new Song(kashmirLedZ);
+
+// class Album extends Song {
+//
+//   constructor(songs) {
+//     super(songs[0])
+//     this.tracks = songs
+//     this.songCount = this.tracks.length
+//
+//   }
+//
+// }
+//
+// let newAlbum = new Album()
diff --git a/music-player/songNew.js b/music-player/songNew.js
new file mode 100644
index 0000000..9601d41
--- /dev/null
+++ b/music-player/songNew.js
@@ -0,0 +1,23 @@
+class Song {
+//agrument passed as an object
+  constructor(song){
+   this.title = song.title;
+    //in seconds
+    this.songLength = song.songLength;
+    this.album  = song.album;
+    this.artist = song.artist;
+    this.track = song.track;
+    this.genre = song.genre;
+    this._isPlaying = false;
+  }
+
+  Play( ) {
+      this._isPlaying = true;
+      console.log('I am playing a song ' + this.title);
+  }
+
+  Pause ( ){
+      this._isPlaying = false;
+      console.log(this.title + ' is now paused');
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..a2894d4
--- /dev/null
+++ b/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "oop-practice",
+  "version": "1.0.0",
+  "description": "A place to practice object-oriented programming (OOP) in JavaScript.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReanyAlex/oop-practice.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/ReanyAlex/oop-practice/issues"
+  },
+  "homepage": "https://github.com/ReanyAlex/oop-practice#readme"
+}