Category: Javascript frameworks

  • Blazor – Best Framework for application development

    Blazor – Best Framework for application development

    On the front-end, businesses turning towards digitalization are focused on one particular thing, to simplify the user experience and making any solution as user-friendly as possible. At the back-end of this, it meant developers creating strenuous codes and javascript programs to provide easier functionalities. In recent times, however, different platforms are making this easier for developers to create better solutions with in-built components, easier languages and responsive libraries. One such framework that is showing promising results is Blazor, from Microsoft.

    Blazor is still fairly new in the world of front-end development, but can be used to develop various client-side web UIs using an assortment of C#, HTML and CSS instead of JavaScript, a feat which has been happily welcomed by developers. This free, open-source web framework makes use of the latest web standards and can build highly interactive web apps, without need of any additional plugins or add-ons to run. It uses the existing HTML Document Object Model (DOM) in CSS Styling to process UI components, but can also be shared across different platforms as it uses C# for processing.

    There are two different methods followed today, to develop Blazor applications. The client-side Blazor, which runs directly on the browser, makes use of Web Assembly to run the code, while the server-side Blazor runs the same code, but on a server.

    • Blazor Web Assembly:

    When building applications using Blazor Web Assembly, the Blazor code can be run inside of the .NET runtime, on top of Web Assembly (Wasm), so that the compiled code is directly running in the browser, acting as the host for the applications. This also enables to run the applications offline, as well as create low latency applications, due to its near-native runtime speed. As Wasm is compatible with all major browsers, Blazor can be run on all major browsers, including web browsers.

    • Server-side Blazor:

    In the server-side model, the Blazor application is run on top of .NET coretime, with a real-time two-way SignalR connection with the server. The application can surprisingly handle more than 20000 active users concurrently, without any glitch in the performance. The only condition which is required in this case is that the application requires a constant connection to the server.

    These types of Blazor applications do come with their own set of challenges, but one can be reminded that the framework is in its very nascent stage and undergoing constant development. However, it does provide with many pros which are helping users to experiment with developing web and mobile apps.

    Features of Blazor:

    • For Client-side Blazor:
      • Compiles and runs .NET code directly in the browser in C#.
      • Its compiled nature enables it to run faster than a similar logic from Javascript.
      • As it does not pass each action through the server, it enables user to run the app offline.
      • Both the client side and the server side can be applied with the same validation code.

    • For Server-side Blazor:
      • It is completely compatible with every .NET library and .NET tooling, as it is it is essentially a ASP.NET core application.
      • Uses the exact same syntax as client-side Blazor, which allows developers to write a class library in either of the two Blazor modes.
      • It is interoperable with Javascript APIs and libraries, so that a developer can continue using them, while writing the logic in C#.

    Having two distinct types of Blazor modes, one can choose the right fit for any project based on the nature of the project. Each one has its own pros and cons, but the platform provides the needed flexibility to create applications as desired.

    The future of Blazor seems bright, and soon, it might become a single UI Framework for creating any .NET application. This open-source framework has been a dream for many new-age developers, who do not want to learn the javascript to be able to create applications. C# is evolving every day and adapting to the capabilities shown by other languages. Thanks to platforms like Blazor, it is gaining huge popularity.

    In the days to come, Blazor will undergo its own fine-tunings but has already shown a lot of promise. Though it is not meant to completely replace JavaScript, the introduction of Blazor has enabled C# and .NET to expect a very exciting road ahead.

    If you want to learn more about how Blazor can help you with your new idea, you can connect with us at support@stw-services.com.

  • Flutter: The future of hybrid mobile development

    Flutter: The future of hybrid mobile development

    Mobile app and web development is one of the most challenging tasks today. With the competition to represent almost every company on the digital front constantly increasing, be it a mobile application or web platforms, developers today are expected to work smarter and more efficiently to develop ideas. With the need of developing mobile apps on both, Android and iOS, the future of mobile apps is without a doubt, turning towards hybrid development.

    One of the additions to the hybrid app development scene, since 2015, is Flutter – a powerful UI Toolkit created by Google, for building native applications for mobile and web, from a single codebase. Flutter is an open source framework, providing a simple and powerful SDK to write applications in Dart, a language created by Google. Over a short period of time, it has been widely accepted in the industry as a strong, reliable platform, thanks to some of its unique features and efficiency.

    One of the biggest strengths of the platform is the hot reload feature, which helps developers to build UIs, fix bugs, add features and explore possibilities on physical or virtual screens, in the debug mode, by simply injecting the changes in the Dart Virtual Machine (VM) mode.  Flutter then automatically rebuilds the widget tree, while preserving the original state of the app. Thus, the developer can view the effects of the most recent changes in real-time, without eliminating the current state.The advantages which Flutter promises over the other platforms are not only a more streamlined approach in mobile app development, but an overall enhanced experience for both, the developers, as well as the end-users.

     

    The advantages which Flutter promises over the other platforms are not only a more streamlined approach in mobile app development, but an overall enhanced experience for both, the developers, as well as the end-users.

    • A single code-base for both Android and iOS applications needs to be written. This also means faster performance, lesser testing time and more efficient maintenance.
    • Easy-to-use and great developer tools, with amazing customization capabilities.
    • Dart language is simple to learn and comes with a large repository of packages to help extend application capabilities.
    • Flutter boasts of a huge catalog of ready-to-use Material Design and Cupertino widgets, along with complete control over the layout. Flutter widgets support hand gestures and animations, for a better app features.
    • Beautiful user interfaces for a smooth experience for end-users.

    In a competitive market, which is flooded with competition, Flutter has made a name for itself as one of the most promising app development platforms. Through its simplistic development process and higher performance, Flutter gives developers complete freedom to build mobile applications in a way, which is truly platform-independent. The framework has been widely accepted by the mobile application market and is being used by even larger players and renowned tech-companies.

    What remains to see in the near future is the capabilities which mobile app developers can bring out through Flutter, to create magic on mobile screens.

  • Why is Java Script considered as the future?

    Why is Java Script considered as the future?

    Java Script is a light weight, object-oriented programming language with top built-in functions and is best known as a scripting language for webpages. But, it is also used in many non-browsing environments as well.

    Java Script is ruling the digital world today. Web pages, mobile apps, cloud services, IOT Devices – they all rely more and more on Java Script. The importance of Java Script as a web technology can be determined from the fact that it is currently used in 94.5% of all websites present on the internet. This explains a lot, right? Understanding and learning Java Script is vitally important for everyone related to the IT hub.

    Let’s explore some reasons for the tremendous popularity and success of Java Script –

    • Platform Independence

    Java Script is a universal language. Having the entire codebase on this language comes with its own benefits. You can reuse a lot of code. You can use the same packages for all your projects, same package manager, task runner, module bundler, libraries and all the other tools and services you can think of. There’s no need to re-write the same code each time on a new platform.

    • Implement Client-Side Scripts

    Initially designed as a client-side scripting language, a large percentage of websites still use Java script for the same. Developers can easily write custom client-side scripts in Java Script and seamlessly integrate these scripts into HTML.

    • Enables Server-Side Code Writing

    Web Developers can also write server-side code in Java Script using a cross platform runtime engine like Node.js. Node.js executes the Java Script codes efficiently and smoothly without relying on external web sources owing to the built-in libraries it provides. Hence web developers can use Node.js to write both Client-Side and Server-Side code in Java Script.

    • Simplifying Complex Application Design

    Despite being an interpreted programming language, complex web application development can be simplified by Java Script by allowing developers to simplify the application composition. Programmers can use Java Script libraries to create shadow DOM (Document Object Module) boundaries, which simplifies the application’s structure and dissever components of individual Java Script libraries.

    • Numerous Transpilers

    Java Script is a light-weight programming language. It lacks some of the advanced and robust features provided by modern programming languages like Java and C#. But developers can easily extend Java Script by using various transpilers like CoffeeScript, TypeScript, DukeScript etc. Each transpiler enables the developer to meet the requirements of large and heavy applications.  

    • Responsive Web Designs

    Developers nowadays adopt responsive web design to make a website accessible and attractive across multiple browsers and devices. Responsive Web Design enables the developer to optimize a website for both computers and mobile devices using the same codebase.

    • Fully-Featured Libraries and Frameworks

    The web developers can easily extend the functionality of Java Script by using numerous libraries and frameworks. Libraries like Angular JS and Ember enables the developers to add functionality to complex web applications without having the need to write additional code.

    • Consistent Evolution

    As mentioned earlier, Java Script lacks some advanced features provided by modern programming languages like multithreading and file read/write option. But the programming language has been evolving consistently to meet the emerging trends of web application development.

    Java Script has proved to stand out of the many strong and powerful languages, and is turning out to be the universal language for developers. It’s potential for the future is enormous as its functionality tends to ease the work of programmers. You can’t avoid it, so why not master it.

  • React Native Installation iOS and Windows : Part 1

    React Native Installation iOS and Windows : Part 1

    React Native Installation iOS and Windows : Part 1- We often need to list youtube video of a playlist and play it in Android and IOS App . Youtube easily provide data in xml by playlist id. Here I am going to explain how to parse video xml and play video using WebView component in react native.

    Page 1: React native installation process on windows and ios

    IOS:

    Dependencies for IOS

    1. XCODE from App Store https://developer.apple.com/xcode/
    2. Copy code from brew.sh and paste in terminal. Press Enter
    3. Node : brew install node
    4. Watchman: brew install watchman
    5. React Native CLI: npm install -g react-native-cli

    Finally run command to create your project.Please open terminal and run this command:

    react-native  init youtube_video
    To open Simulator. Please run this command

    1.  cd youtube_video
    2. react-native run ios

    Window:

    Installation of Dependency for Window. It is long process

    1. Installation of Java http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
    2. Installatiion of Node Js : https://nodejs.org/en/
    3. Installtion of Android Studio : https://developer.android.com/studio/index.html
    4. Then open command prompt in window , win + r, type cmd then press enter
    5. Run command npm install -g react-native-cli
    6. Then install react native in drive where you like
    7. Type E: or C: or D: where you want to install
    8. Run command react-native init youtube_video ( or which name you like )
    9. Open android studio and click on open an existing android project
    10. Please select android folder in your youtube_video folder and click ok
    11. Open message tab in android studio and if you see any update please click on link if it is there
    12. Create virtual device:  Open Tool menu on top then android > AVD Manager
    13. Click on create virtual device select which device you want to add as i select Nexus 5 click on next then click on download button of Marshmallow
    14. On popup window you will see installation start and after finish click on finish button
    15. Then in window select Marshmallow and click on next and on next window click on finish
    16. You can see you virtual device in list , In action column click on green arrow to open it
    17. Now we need to set environment of our system
    18. Search system setting in window search then select View Advance System Setting
    19. Select Advance tab
    20. Click on Environment variables button
    21. In user variable section , please click on new button
    22. Variable name :  JAVA_HOME
    23. Variable Value: Then click on browse directory and select path where android sdk folder so click on c: > Program Files > Java > jdk1.8.0 (what is folder name of java there)
    24. click on path on user variable then click edit and click on new button and enter c:\Users\Computer\AppData\Local\Android\sdk\platform-tools
    25. to check this open any directory and type this path in top path bar you will see all files and folder of sdk folder
    26. Now open command prompt and cd your project directory path run react-native run-android and you can see your project in similator now

    We are all done for window

  • Registering Component in React Native : Part 2

    Registering Component in React Native : Part 2

    Registering component process in react native, open your project folder. In root you can see index.js and App.js . In older version files name are index.ios.js and index.android.js. But it does not matter if you are coding for android you can use index.android.js and if you are coding for IOS you can use index.ios.js

    In updated installation index.ios.js and index.android.js are removed and index.js and app.js is added as root file

    So If you have index.android.js , please use this file as your root android file and as i have index.js and app.js i will use app.js as root file

    Index.js : This file use to import App component from app.js file

    App.js: this file has code which is used to display landing screen of app

    So I am going to use app.js to start our application . in app.js remove all code and write following code

    import React, { Component } from 'react';

    This code is importing React and Component from react which we will use later in our app. Use of importing Component is  to extends class of our component.

    Now we will import design element component View and text using react native so we will write second line

    import { View, Text } from 'react-native';
     

    View and Text these component help us to design our application. We can apply css to it . View work as container and text work as to write text in it

    Now we will register our component so

    class YoutubeVideo extends Component {
        render() {
            return (
                <View>
               <Text>Youtube Video</Text>
              </View>
            )
          }
    }

    Now we will export this component by adding line blow

    export default YoutubeVideo;

    So your complete code will look like this

    import React, { Component } from 'react';
    
    import { View, Text } from 'react-native';
    
    
    class YoutubeVideo extends Component {
    
        render() {
    
            return (
    
            <View>
    
            <Text>Youtube Video</Text>
    
            </View>
    
           );
    
         }
    
    }
    
    
    export default YoutubeVideo;

    In above code you can see we created a component YoutubeVideo and export it for import on another file, If you will not use export you can’t import it on another file for use

    Now we will import and register this component in index.js file

    Open index.js file

    Now change App import to YoutubeVideo

    import App from './App';

    You will see code like this

    Change to

    import YoutubeVideo from './App';


    One important thing is here as you can see code is written … from ‘./App’; . Actually we do not use .js extension when we import any component from any file . we just write file name only so App.js is written only as App

    Now we will register our component to our application

    So now you can see code below AppRegistry. AppRegistry use to register component with app . like we have main component YoutubeVideo so we will register this main component with our app. So to do this we will change last line of AppRegistry

    AppRegistry.registerComponent('youtube_video', () => App);

    You can see line like this . But we have imported our component as YoutubeVideo so we will change App to YoutubeVideo. Now our line should look like this

    AppRegistry.registerComponent('youtube_video', () => YoutubeVideo);

    youtube_video this is our project name which we created using react init command above

    Now our main component is created and registered to app

    Open simulator and click r button two times

    Now you can a your text on screen which we added in app.js file using <Text></Text>

    So your screen is ready with your component to move further

    So your complete code will look like this

  • Header Card Component in React Native : Part 3

    Card component use to create Header in react native. Now we will create a common folder for common design component . By Using props and children props we will get data in these design component.

    Create new folder src in your project folder

    Now create a new folder common in src folder

    So your folder hierarchy will be

    Youtube_video

    -src

    — common

    Adding Header file

    Now create Header.js file in common folder and open it in editor

    Please open Header.js file in editor and import React, Component, View and Text . So we will do same thing as we did before

    import  React, { Component } from 'react';
    
    import  { View, Text } from 'react-native';

    Now we will create Header component

    class Header extends Component {
        render() {
            return (
              <View>
                <Text>Header Text Here</Text>
             </View>
           );
         }
    }

    Now we will export this header. So add last line in Header.js

    export default Header;

    Now our Header component is ready to export . Now we will import this header in App.js so open App.js and write below last import line

    import  Header from './src/common/Header';

    Now call Header in View in App.js

    So we will write <Header /> just above <Text> , so now our App.js code will be like this

    class YoutubeVideo extends Component {
    
        render() {
    
            return (
    
                <View>
    
                    <Header />
    
                    <Text>Youtube Video</Text>
    
                </View>
    
           )
    
        }
    
    }
    
    export default YoutubeVideo;

    Now press two time r button and see result. You will se yout Header text above application

    we will call header text easy to change from App.js easily using props. Props carry parameter which is useful to customize component

    So add a prop in Header in App.js

    <Header HeaderText='My Youtube Play List' />

    So change line <Header /> to

    Here HeaderText is prop . you can name prop anything what you like to keep and now we will call this prop in Header.js. So replace text in Header component Text component

    <Text>Header Text Here</Text>
    change to
    <Text>{ this.props.HeaderText }</Text>

    Props we call in curly braces using this.props. So finally your header code will look like this in Header.js

    import  React, { Component } from 'react';
    
    import { View, Text } from 'react-native';
    
    
    class Header extends Component {
    
        render() {
    
            return (
    
             <View>
    
              <Text>{ this.props.HeaderText }</Text>
    
            </View>
    
           );
    
        }
    
    }
    
    
    export default Header;

    Styling Header Component

    Now before export default Header; line in Header.js file, we will create style component and we will call it in Header component. So

    const Styles = {
    
    
        HeaderStyle: {
    
            justifyContent: 'center',
    
            alignSelf: 'stretch',
    
            alignItems: 'center',
    
            paddingTop: 20,
    
            paddingBottom: 20,
    
            paddingLeft: 20,
    
            paddingRight: 20,
    
            elevation: 2,
    
            backgroundColor: '#ff0000'
    
    }
    
    };

    justifyContent place content vertically center  in a view

    alignItems place inside content center in a view

    Here all details are added if you would like to learn more https://facebook.github.io/react-native/docs/layout-props.html

    Now we will apply this style to View component. So we will call like this

    style={Styles.HeaderStyle}

    So now change in View component of Header.js. It should look like this

    <View style={Styles.HeaderStyle}>
    
    <Text>{ this.props.HeaderText }</Text>
    
    </View>

    Now we will design Text Component. So we will create another skyle in same Styles const

    Add comma after HeaderStyle curly braces and start adding new style so

    HeaderText: {
    
        fontSize: 20,
    
        color: '#FFFFFF'
    
    }
    const Styles = {
    
    
        HeaderStyle: {
    
            justifyContent: 'center',
    
            alignSelf: 'stretch',
    
            alignItems: 'center',
    
            paddingTop: 20,
    
            paddingBottom: 20,
    
            paddingLeft: 20,
    
            paddingRight: 20,
    
            elevation: 2,
    
            backgroundColor: '#ff0000'
    
    
    },
    
    HeaderText: {
    
        fontSize: 20,
    
        color:  '#FFFFFF';
    
    }
    
    
    }

    your final Styles code will be

    Now we will call this HeaderText style in Text component . So we will add like same way

    <View style={Styles.HeaderStyle}>
    
    <Text style={Styles.HeaderText}>{ this.props.HeaderText }</Text>
    
    </View>

    Now refresh simulator you will see a better look for header something like this

  • Card Design with Props and Children : Part 4

    Card Design is just like to create a boxes to hold Video Title, Video Image and Click button. By Adding some shades border by styling we will add a good design view for all listing. These are common component which we can use many places in app

    Now we will create Cards Wrapper and CardsInner so for this we will create new files

    CardWrapper.js and CardsInner.js in common folder of src folder

    Creating CardWrapper

    Open CardWrapper.js file and start importing components from react and react native

    import React, { Component } from 'react';
    import { View } from 'react-native';
    
    class CardWrapper extends Component {
      render() {
      return (
      <View>
          {this.props.children}
      </View>
      );
     }
    }

    Here i have added this.props.children this will call the component which we will add inside CardWrapper 

    For example if we import CardWrapper and call it like

    <CardWrapper>
    <View>

    <Text>Something here to write</Text>

    </View>
    </CardWrapper>

    So this.props.children will return all code inside <CardWrapper></CardWrapper>
    component as children props. I will show you its use further in below code. It will be more clear for you

    Styling Card Wrapper

    Now we will add some styling to Card Wrapper. So create WrapperStyle

    const Styles = {
        WrapperStyle: {
          borderWidth: 1,
          borderRadius: 2,
          borderColor: '#ddd',
          borderBottomWidth: 0,
          shadowColor: '#000',
          shadowRadius: 2,
          elevation: 5,
          marginLeft: 5,
          marginRight: 5,
          marginTop: 10
        }
    };

    Now we will add this style to CardWrapper component. So add this code in CardWrapper View

    <View style={Styles.WrapperStyle}>
    {this.props.children}
    </View>

    So final code will look like this

    import React, { Component } from 'react';
    import { View } from 'react-native';
    
    class CardWrapper extends Component {
     render() {
      return (
       <View style={Styles.WrapperStyle}>
        {this.props.children}
      </View>
      );
     }
    }
    const Styles = {
        WrapperStyle: {
          borderWidth: 1,
          borderRadius: 2,
          borderColor: '#ddd',
          borderBottomWidth: 0,
          shadowColor: '#000',
          shadowRadius: 2,
          elevation: 5,
          marginLeft: 5,
          marginRight: 5,
          marginTop: 10
        }
    };
    
    export default CardWrapper;

    Creating Card Inner

    Now open CardInner.js and start import component from react and react-native

    import React, { Component } from 'react';
    import { View } from 'react-native';
    
    class CardInner extends Component {
    render() {
         return (
          <View>
          {this.props.children}
          </View>
        );
    }
    }
    
    export default CardInner;

    Now add style in same way as added for Cardinner component. So now add CardStyles

    So now add CardStyles

    Now we will add Style to CardInner component View

    1. <View style={Styles.CardStyles}>
    2. {this.props.children}
    3. </View>
    import React, { Component } from 'react';
    import { View } from 'react-native';
    
    class CardInner extends Component {
      render() {
        return (
        <View style={Styles.CardStyles}>
           {this.props.children}
        </View>
        );
      }
    }
    const Styles = {
      CardStyles: {
        borderBottomWidth: 1,
        padding: 5,
        backgroundColor: '#FFF',
        justifyContent: 'flex-start',
        flexDirection: 'row',
        borderColor: '#ddd',
        position: 'relative'
      }
    };
    export default CardInner;

    If you are eager  to check how this long CardWrapper and CardInner will look. So just import both in App.js file and this line for test

    import CardWrapper from ‘./src/common/CardWrapper’;
    import CardInner from ‘./src/common/CardInner’;

    And add this test code inside view tag

    <CardWrapper>
    
             <CardInner><Text>Title</Text></CardInner>
    
             <CardInner><Text>Image</Text></CardInner>
    
             <CardInner><Text>Play Button</Text></CardInner>
    
    </CardWrapper>

    Now refresh Simulator by pressing r button two times and it will show result

    If it is working please remove recent code of import and CardWrapper and CardInner. We will use these designs later in listing

    So it was a long Code but hope you understand following things

    – How create component

    – How Import other component

    – How design a component

    So our design is ready now we will use these cards to list youtube videos. So first we will select a playlist 

  • Youtube video XML url : Part 5

    Youtube video XML url : Part 5- So open youtube.com and open a play list

    Search a channel on youtube and open it. You will find a playlist tab . Open that tab and it will display playlist. Click on any play list and you will see url of play list

    https://www.youtube.com/watch?v=DPbnQFxdpPg&list=LLA34Z3lq8FozSQzDHsSLcmQ

    In this url last parameter is playlist id LLA34Z3lq8FozSQzDHsSLcmQ

    By using this playlist id you can find xml data of youtube videos

    So we will now use video.xml url of youtube to display xml data

    https://www.youtube.com/feeds/videos.xml?playlist_id=LLA34Z3lq8FozSQzDHsSLcmQ

    We will get Title , thumnail url and video id from this xml feed to display list of all videos. To achieve this goal we need to parse xml and get data.

    This process I will describe in further Step

  • Design Video List Component : Part 6

    Design Video List Component : Part 6- Create a components folder in src folder and add VideoList.js file in it, open this file and start importing component

    1. import React, { Component } from ‘react’;
    2. import { View, Text } from ‘react-native’;
    3. import CardWrapper from ‘../common/CardWrapper’;
    4. import CardInner from ‘../common/CardInner’;
    5. class VideoList extends Component {
    6. render() {
    7. return (
    8. <View>
    9. <CardWrapper>
    10. <CardInner>
    11. <Text>For Title</Text>
    12. </CardInner>
    13. <CardInner>
    14. <Text>For Image</Text>
    15. </CardInner>
    16. <CardInner>
    17. <Text>For Button</Text>
    18. </CardInner>
    19. </CardWrapper>
    20. </View>
    21. );
    22. }
    23. }
    24. export default VideoList;

    So here we created a base design for video listing. No further we will call this component in a file Index.js and pass props of playlist id id from index.js and get it on VideoList.js

    If we will keep Play list id from Parse code of VideoList , That will be easy for us to change any time Play List id of youtube and easily we can list any playlist by a quick change


    So Now we are going to create Index.js in same component folder. And Add

    1. import React, { Component } from ‘react’;
    2. import { View } from ‘react-native’;
    3. import VideoList from ‘./VideoList’;
    4. class Index extends Component {
    5. render() {
    6. return (
    7. <View>
    8. <VideoList playlistid=’LLA34Z3lq8FozSQzDHsSLcmQ’ />
    9. </View>
    10. );
    11. }
    12. }
    13. export default Index;

    In this code I imported VideoList component and called it in view component of Index component. You can see I am passing playlistid as props in VideoList component. It is same process which I did in Header Component

    Now further we are going to get this playlistid props on VideoList component and print it in console to see what is result

    So now we will call Index component in our main App.js file so we can see what is result when app load

    So open App.js and import Index component

    1. import Index from ‘./src/components/Index’;

    Now remove Text component


    <Text> Youtube Video </Text>

    And add Index component

    <Index />

    So now its time to refresh simulator again and check what is result .

    Great!! We did .

    Now we will run debugger in simulator to check our props . So we will call console.log in render method of VideoList.js.

    So to run debugger in chrome press command + M button. And select Debug Js Remotely

    http://localhost:8081/debugger-ui/ this url will open in chrome. Right click in chrome and open inspect

    Click on console

    Now we will console.log(this.props.playlistid); in render() { method of VideoList.js

    So code will be like this

    ……
    class VideoList extends Component {

     render() {

       console.log(this.props.playlistid);

       return (

    …….

    Now its time to refresh simulator and check chrome console you will see same playlist id which we passed in props

    🙂

    Well , we are getting play list id of youtube