Edward Jackson

Edward Jackson

1565161713

Why Webpack is important for Front-End Developer

The field of Front-End development is changing so rapidly on how we do things these days. Back when life was so simple and before front-end libraries and frameworks started appearing, there used to be just a simple Javascript file that you have to include in your html file and you’re good to go.

In CSS we have a couple of libraries and frameworks to use these days. This makes front-end development more and more challenging. The same can be said with JavaScript ecosystem. Not only that we have changing libraries and frameworks to use, but we also have changed the standards these days like ES6 and beyond. Big three frameworks like Angular, React, Vue came into play the past few years.

Then came these so-called “module bundlers” or build tools, namely webpack, browserify, and gulp.

If you’re wondering how did our tooling became more and more complicated that we have to use build tools like webpack, let us go back in the days where web development was so simple that including a simple script is already enough.

What is Webpack?

First, let us define what is Webpack. According to the official site, Webpack is a static module bundler for modern JavaScript applications. It builds a dependency graph that is responsible for bundling all your javascript modules into one regardless where they are located when one javascript file depends on each other.

In short, Webpack is a bundler that is responsible for bundling all your javascript files to make it work.

The time before libraries, frameworks, and build tools like Webpack

Back then life was so much simpler that we just need to include a single script in our HTML such as this then solve problems right away:

<head>
   <script src="main.js" type="text/javascript"></script>
 </head>

But then, libraries came so we have to include them one by one and in the proper order to make them work interdependently:

<head>
   <script src="library1.js" type="text/javascript"></script>
   <script src="library2.js" type="text/javascript"></script>
   <script src="script.js" type="text/javascript"></script>
 </head>

Then the ecosystem added frameworks such as Ember, Backbone, Meteor, React, Vue, Angular and things got complicated from there. Add in some more changing standards of Javascript like ES6, ES7 and beyond.

Then lastly came build tools such as browserify, grunt, webpack and we totally got lost in the sea of uncharted waters of Front-End ecosystem:

var webpack = require("webpack");
var path = require("path");
var HtmlWebpackPlugin = require("html-webpack-plugin");
const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;

module.exports = {
entry: {
bundle: ‘./src/index.js’
},
output: {
path: path.join(__dirname, “…/dist”),
//note: we changed bundle name into a variable [name] to get the key values in entry property instead of declaring the name statically.
//[chunkhash] - this is a large string of characters that uses hash. If vendor or javascript files were updated, webpack will automatically bundle the contents of the file then generate a different hash.
filename: “[name].[chunkhash].js”
},
mode: “development”,
devtool: “inline-source-map”,
devServer: {
proxy: {
‘/api’: {
target: “http://localhost:3000”,
secure: false,
changeOrigin: true
}
}
},
module: {
rules: [
{
use: {
loader: “babel-loader”
},
test: /.js$/,
exclude: /node_modules/ //excludes node_modules folder from being transpiled by babel. We do this because it’s a waste of resources to do so.
},
{
use: [‘style-loader’, ‘css-loader’],
test: /.css$/
}
]
},
plugins: [
//manifest - Gives the browser a better understanding that tells whether the vendor file has actually got changed.
// new webpack.optimize.CommonsChunkPlugin({
// names: [‘vendor’, ‘manifest’]
// }), //We need to include this plugin so that it never duplicates the libraries that were included in vendor.js within bundle.js as well
new HtmlWebpackPlugin({
template: ‘src/index.html’
}), //this plugin is responsible for injecting the entry scripts of webpack (such as bundle.js and vendor.js) inside the html file without specifying them manually.
new webpack.DefinePlugin({
‘process.env.NODE_ENV’: JSON.stringify(process.env.NODE_ENV) //we will set the correct variable for process.env.NODE_ENV variable inside the scripts property in package.json
}), //This adds windows-scoped variables that will be defined in bundle.js
// new BundleAnalyzerPlugin()
],
optimization: {
splitChunks: {
chunks: ‘async’,
minSize: 30000,
maxSize: 0,
minChunks: 1,
maxAsyncRequests: 5,
maxInitialRequests: 3,
automaticNameDelimiter: ‘~’,
name: true,
cacheGroups: {
commons: {
test: /[\/]node_modules[\/]/,
name: ‘vendors’,
chunks: ‘all’
},
default: {
minChunks: 2,
priority: -20,
reuseExistingChunk: true
}
}
}
}
};

 

var webpack = require(“webpack”);
var path = require(“path”);
var HtmlWebpackPlugin = require(“html-webpack-plugin”);
const CompressionPlugin = require(“compression-webpack-plugin”);

module.exports = {
entry: {
bundle: ‘./src/index.js’
},
output: {
path: path.join(__dirname, “…/dist”),
//note: we changed bundle name into a variable [name] to get the key values in entry property instead of declaring the name statically.
//[chunkhash] - this is a large string of characters that uses hash. If vendor or javascript files were updated, webpack will automatically bundle the contents of the file then generate a different hash.
filename: “[name].[chunkhash].js”
},
mode: “development”,
devServer: {
proxy: {
‘/api’: {
target: “http://localhost:3000”,
secure: false,
changeOrigin: true
}
}
},
module: {
rules: [
{
use: {
loader: “babel-loader”
},
test: /.js$/,
exclude: /node_modules/ //excludes node_modules folder from being transpiled by babel. We do this because it’s a waste of resources to do so.
},
{
use: [‘style-loader’, ‘css-loader’],
test: /.css$/
}
]
},
plugins: [
new HtmlWebpackPlugin({
template: ‘src/index.html’
}), //this plugin is responsible for injecting the entry scripts of webpack (such as bundle.js and vendor.js) inside the html file without specifying them manually.
new webpack.DefinePlugin({
‘process.env.NODE_ENV’: JSON.stringify(‘production’) //we will set the correct variable for process.env.NODE_ENV variable inside the scripts property in package.json
}) //This adds windows-scoped variables that will be defined in bundle.js
],
optimization: {
minimize: true,
splitChunks: {
chunks: ‘async’,
minSize: 30000,
maxSize: 0,
minChunks: 1,
maxAsyncRequests: 5,
maxInitialRequests: 3,
automaticNameDelimiter: ‘~’,
name: true,
cacheGroups: {
commons: {
test: /[\/]node_modules[\/]/,
name: ‘vendors’,
chunks: ‘all’
},
default: {
minChunks: 2,
priority: -20,
reuseExistingChunk: true
}
}
}
}
};

I have to admit that when I heard and read these stacks to learn in the developer community, I was one of the developers that got intimidated in climbing the Front-End ecosystem until I gave it a break then started giving it a shot again.

How did we get into this mess?

First, let us ask how did we actually get into this mess and what problems do build tools like webpack solve.

These are the problems webpack was trying to solve:

Automation

You might not be a big fan of including every Javascript libraries in your HTML headers but prefer to use npm for including such libraries you want to use in your functionality.

Webpack does that for you. You just simply need to install any library of choice you want from npm then webpack can automatically include that library in the bundle for you if you’re making use of them in your modules.

Load Speed

Loading individual scripts within a webpage is very costly if we were to create a modern web app.

Webpack helps us improve the loading speed by bundling every Javascript modules we have into one since we only ask once in fetching our script from the webserver. It makes sense since when we just fetch our javascript files one by one, we’re putting stress on webserver by fetching those files a couple of times in contrast to one big file being requested from webserver.

This might be true prior to the advent of HTTP/2, but things might have changed since then.

Only load necessary scripts when needed

Under normal circumstances, your app will load every javascript modules and libraries you had regardless if you need these functionalities or not. But what if at some point you don’t need some of the libraries in that particular functionality or module the user is using as of the moment?

Take a look at this graph in our developer console:

The red on the graph indicates the percentage of scripts unused in your app, while the green ones indicate it is being used. When you think about it, we have more unused scripts that are unnecessarily loaded during loading time.

With this, webpack provides a feature called “code splitting” to solve this problem. What this does is that you have a choice to load individual scripts “on-demand” or “asynchronously” only when the app needed it. This gives us the performance edge we need to load the app at blazing speeds.

Because of this feature, we don’t need to load any unnecessary scripts that only hampers the performance when the user is not using some particular modules or functions.

For more information about code splitting, visit webpack’s official documentation for it

Dependency Issues

Another reason why webpack is so popular because it solves the common problem in building javascript apps: Dependency issues.

As mentioned earlier, before the dawn of webpack, we used to arrange our scripts and libraries in the proper order to connect the dependencies correctly:

<script src=“moment.min.js”></script>

<script src=“typeahead.min.js”></script>

<script src=“jquery.min.js”></script> 

<script src=“otherplugins.min.js”></script>

<script src=“main.js”></script>

This is fine. But as your list of libraries you depend on gets broader, you will encounter some dependency issues because you haven’t imported the script in proper order. I encounter this issue a lot when my list of libraries I depend to gets broader and broader.

But as I used webpack, this solves all the dependency issues I previously had because you will know ahead of time which dependencies were missing during the build time through the use of ECMAScript Modules (ESM) like so:

//helper.js

export const sqrt = Math.sqrt;

export function square(x) {

    return x * x;

}

export function diag(x, y) {

    return sqrt(square(x) + square(y));

}

//main.js

import { square, diag } from ‘helper’;console.log(square(11)); // 121

console.log(diag(4, 3)); // 5

These import/export modules will automatically be detected by webpack and will serve as an indicator which javascript modules will it include during the bundle. This effectively takes away the pain of arranging your libraries in proper order just to make everything work.

Despite the problems that it resolves no matter how many, why do we still need to bother ourselves in learning webpack?

Why learn webpack?

To shed some light on this tool, I’ve enumerated the reasons why learning webpack is such a big advantage for you as Front-End Developer. Here are some of the reasons why:

You will understand the modern front-end ecosystem better

As you might have noticed recently, Angular, React, and Vue were already depending on webpack to build boilerplates or ready-made app for developers to start coding their prototype using these major frameworks.

The reason why boilerplates rely on webpack is that it has lots of modules/libraries involved in it like in the case of Angular. Webpack automates the process of downloading/including modules as I mentioned above, so it’s being used often in the frameworks/libraries.

Not only that learning webpack will allow you to gain the benefits mentioned earlier, but you will also understand how front-end boilerplates work under the hood, therefore, understanding the modern front-end ecosystem.

You can speed up development

Development time has also been improved thanks to webpack’s feature called “Hot Module Replacement”. This has been proven to boost productivity because your page doesn’t need to trigger full reload just to reflect your changes on your javascript code.

This not only applies to javascript, but your CSS code can also benefit from this feature by adding css loaders in your webpack config. This makes your development time insanely fast and cutting back the time it takes for the page to fully load while debugging.

You can setup Single-Page Applications better

You can actually see the benefits in using webpack especially if you’re developing Single Page Applications.

When you learn webpack, you will easily be able to setup Single Page Applications. This is especially true when you’re using React since webpack can use transpilers such as Babel alongside it to transpile JSX syntax into readable javascript code.

Total control over build system

You can choose various build systems you’ll need with webpack if there are any such as using babel or traceur via webpack loaders if you need to transpile your ES6+ code in previous versions to make your javascript code compatible with older browsers.

Either way, you always have control over it Babel

Conclusion

I hope I shed some light on the reasons why webpack is such an awesome tool to add in your day to day Front-End Development work. Although not all the time you’re gonna need this tool in every Front-End Development project you have.

In my personal experience, you will more likely to rely on webpack if you’re using React. But otherwise, you’re fine if the solutions offered by webpack don’t benefit you or doesn’t fit in your use-case.

If you’re struggling in learning webpack, I suggest making use of existing boilerplates first to set up your web app quickly then slowly learn webpack along the way:

Angular CLI

Vue CLI

Thanks for reading

If you liked this post, share it with all of your programming buddies!

Follow us on Facebook | Twitter

Further reading about Webpack

Webpack 4 in 2019: The Complete Tutorial For Beginners

Webpack 4: Beyond the Basics

JavaScript Infrastructure: CLI, NPM, Babel 7 and Webpack 4

Getting started with Webpack

Learn ReactJS with Webpack 4, Babel 7, and Material Design

Getting Started With React.js, Babel 7, Webpack 4, and MobX 5

React + Webpack + TypeScript Project Setup

Webpack 4.30 Tutorial for Beginners 🚀 🚀 🚀

Best JavaScript Frameworks, Libraries and Tools to Use in 2019




#webpack #javascript #web-development

What is GEEK

Buddha Community

Why Webpack is important for Front-End Developer
Hermann  Frami

Hermann Frami

1651383480

A Simple Wrapper Around Amplify AppSync Simulator

This serverless plugin is a wrapper for amplify-appsync-simulator made for testing AppSync APIs built with serverless-appsync-plugin.

Install

npm install serverless-appsync-simulator
# or
yarn add serverless-appsync-simulator

Usage

This plugin relies on your serverless yml file and on the serverless-offline plugin.

plugins:
  - serverless-dynamodb-local # only if you need dynamodb resolvers and you don't have an external dynamodb
  - serverless-appsync-simulator
  - serverless-offline

Note: Order is important serverless-appsync-simulator must go before serverless-offline

To start the simulator, run the following command:

sls offline start

You should see in the logs something like:

...
Serverless: AppSync endpoint: http://localhost:20002/graphql
Serverless: GraphiQl: http://localhost:20002
...

Configuration

Put options under custom.appsync-simulator in your serverless.yml file

| option | default | description | | ------------------------ | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | | apiKey | 0123456789 | When using API_KEY as authentication type, the key to authenticate to the endpoint. | | port | 20002 | AppSync operations port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20002, 20012, 20022, etc.) | | wsPort | 20003 | AppSync subscriptions port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20003, 20013, 20023, etc.) | | location | . (base directory) | Location of the lambda functions handlers. | | refMap | {} | A mapping of resource resolutions for the Ref function | | getAttMap | {} | A mapping of resource resolutions for the GetAtt function | | importValueMap | {} | A mapping of resource resolutions for the ImportValue function | | functions | {} | A mapping of external functions for providing invoke url for external fucntions | | dynamoDb.endpoint | http://localhost:8000 | Dynamodb endpoint. Specify it if you're not using serverless-dynamodb-local. Otherwise, port is taken from dynamodb-local conf | | dynamoDb.region | localhost | Dynamodb region. Specify it if you're connecting to a remote Dynamodb intance. | | dynamoDb.accessKeyId | DEFAULT_ACCESS_KEY | AWS Access Key ID to access DynamoDB | | dynamoDb.secretAccessKey | DEFAULT_SECRET | AWS Secret Key to access DynamoDB | | dynamoDb.sessionToken | DEFAULT_ACCESS_TOKEEN | AWS Session Token to access DynamoDB, only if you have temporary security credentials configured on AWS | | dynamoDb.* | | You can add every configuration accepted by DynamoDB SDK | | rds.dbName | | Name of the database | | rds.dbHost | | Database host | | rds.dbDialect | | Database dialect. Possible values (mysql | postgres) | | rds.dbUsername | | Database username | | rds.dbPassword | | Database password | | rds.dbPort | | Database port | | watch | - *.graphql
- *.vtl | Array of glob patterns to watch for hot-reloading. |

Example:

custom:
  appsync-simulator:
    location: '.webpack/service' # use webpack build directory
    dynamoDb:
      endpoint: 'http://my-custom-dynamo:8000'

Hot-reloading

By default, the simulator will hot-relad when changes to *.graphql or *.vtl files are detected. Changes to *.yml files are not supported (yet? - this is a Serverless Framework limitation). You will need to restart the simulator each time you change yml files.

Hot-reloading relies on watchman. Make sure it is installed on your system.

You can change the files being watched with the watch option, which is then passed to watchman as the match expression.

e.g.

custom:
  appsync-simulator:
    watch:
      - ["match", "handlers/**/*.vtl", "wholename"] # => array is interpreted as the literal match expression
      - "*.graphql"                                 # => string like this is equivalent to `["match", "*.graphql"]`

Or you can opt-out by leaving an empty array or set the option to false

Note: Functions should not require hot-reloading, unless you are using a transpiler or a bundler (such as webpack, babel or typescript), un which case you should delegate hot-reloading to that instead.

Resource CloudFormation functions resolution

This plugin supports some resources resolution from the Ref, Fn::GetAtt and Fn::ImportValue functions in your yaml file. It also supports some other Cfn functions such as Fn::Join, Fb::Sub, etc.

Note: Under the hood, this features relies on the cfn-resolver-lib package. For more info on supported cfn functions, refer to the documentation

Basic usage

You can reference resources in your functions' environment variables (that will be accessible from your lambda functions) or datasource definitions. The plugin will automatically resolve them for you.

provider:
  environment:
    BUCKET_NAME:
      Ref: MyBucket # resolves to `my-bucket-name`

resources:
  Resources:
    MyDbTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: myTable
      ...
    MyBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: my-bucket-name
    ...

# in your appsync config
dataSources:
  - type: AMAZON_DYNAMODB
    name: dynamosource
    config:
      tableName:
        Ref: MyDbTable # resolves to `myTable`

Override (or mock) values

Sometimes, some references cannot be resolved, as they come from an Output from Cloudformation; or you might want to use mocked values in your local environment.

In those cases, you can define (or override) those values using the refMap, getAttMap and importValueMap options.

  • refMap takes a mapping of resource name to value pairs
  • getAttMap takes a mapping of resource name to attribute/values pairs
  • importValueMap takes a mapping of import name to values pairs

Example:

custom:
  appsync-simulator:
    refMap:
      # Override `MyDbTable` resolution from the previous example.
      MyDbTable: 'mock-myTable'
    getAttMap:
      # define ElasticSearchInstance DomainName
      ElasticSearchInstance:
        DomainEndpoint: 'localhost:9200'
    importValueMap:
      other-service-api-url: 'https://other.api.url.com/graphql'

# in your appsync config
dataSources:
  - type: AMAZON_ELASTICSEARCH
    name: elasticsource
    config:
      # endpoint resolves as 'http://localhost:9200'
      endpoint:
        Fn::Join:
          - ''
          - - https://
            - Fn::GetAtt:
                - ElasticSearchInstance
                - DomainEndpoint

Key-value mock notation

In some special cases you will need to use key-value mock nottation. Good example can be case when you need to include serverless stage value (${self:provider.stage}) in the import name.

This notation can be used with all mocks - refMap, getAttMap and importValueMap

provider:
  environment:
    FINISH_ACTIVITY_FUNCTION_ARN:
      Fn::ImportValue: other-service-api-${self:provider.stage}-url

custom:
  serverless-appsync-simulator:
    importValueMap:
      - key: other-service-api-${self:provider.stage}-url
        value: 'https://other.api.url.com/graphql'

Limitations

This plugin only tries to resolve the following parts of the yml tree:

  • provider.environment
  • functions[*].environment
  • custom.appSync

If you have the need of resolving others, feel free to open an issue and explain your use case.

For now, the supported resources to be automatically resovled by Ref: are:

  • DynamoDb tables
  • S3 Buckets

Feel free to open a PR or an issue to extend them as well.

External functions

When a function is not defined withing the current serverless file you can still call it by providing an invoke url which should point to a REST method. Make sure you specify "get" or "post" for the method. Default is "get", but you probably want "post".

custom:
  appsync-simulator:
    functions:
      addUser:
        url: http://localhost:3016/2015-03-31/functions/addUser/invocations
        method: post
      addPost:
        url: https://jsonplaceholder.typicode.com/posts
        method: post

Supported Resolver types

This plugin supports resolvers implemented by amplify-appsync-simulator, as well as custom resolvers.

From Aws Amplify:

  • NONE
  • AWS_LAMBDA
  • AMAZON_DYNAMODB
  • PIPELINE

Implemented by this plugin

  • AMAZON_ELASTIC_SEARCH
  • HTTP
  • RELATIONAL_DATABASE

Relational Database

Sample VTL for a create mutation

#set( $cols = [] )
#set( $vals = [] )
#foreach( $entry in $ctx.args.input.keySet() )
  #set( $regex = "([a-z])([A-Z]+)")
  #set( $replacement = "$1_$2")
  #set( $toSnake = $entry.replaceAll($regex, $replacement).toLowerCase() )
  #set( $discard = $cols.add("$toSnake") )
  #if( $util.isBoolean($ctx.args.input[$entry]) )
      #if( $ctx.args.input[$entry] )
        #set( $discard = $vals.add("1") )
      #else
        #set( $discard = $vals.add("0") )
      #end
  #else
      #set( $discard = $vals.add("'$ctx.args.input[$entry]'") )
  #end
#end
#set( $valStr = $vals.toString().replace("[","(").replace("]",")") )
#set( $colStr = $cols.toString().replace("[","(").replace("]",")") )
#if ( $valStr.substring(0, 1) != '(' )
  #set( $valStr = "($valStr)" )
#end
#if ( $colStr.substring(0, 1) != '(' )
  #set( $colStr = "($colStr)" )
#end
{
  "version": "2018-05-29",
  "statements":   ["INSERT INTO <name-of-table> $colStr VALUES $valStr", "SELECT * FROM    <name-of-table> ORDER BY id DESC LIMIT 1"]
}

Sample VTL for an update mutation

#set( $update = "" )
#set( $equals = "=" )
#foreach( $entry in $ctx.args.input.keySet() )
  #set( $cur = $ctx.args.input[$entry] )
  #set( $regex = "([a-z])([A-Z]+)")
  #set( $replacement = "$1_$2")
  #set( $toSnake = $entry.replaceAll($regex, $replacement).toLowerCase() )
  #if( $util.isBoolean($cur) )
      #if( $cur )
        #set ( $cur = "1" )
      #else
        #set ( $cur = "0" )
      #end
  #end
  #if ( $util.isNullOrEmpty($update) )
      #set($update = "$toSnake$equals'$cur'" )
  #else
      #set($update = "$update,$toSnake$equals'$cur'" )
  #end
#end
{
  "version": "2018-05-29",
  "statements":   ["UPDATE <name-of-table> SET $update WHERE id=$ctx.args.input.id", "SELECT * FROM <name-of-table> WHERE id=$ctx.args.input.id"]
}

Sample resolver for delete mutation

{
  "version": "2018-05-29",
  "statements":   ["UPDATE <name-of-table> set deleted_at=NOW() WHERE id=$ctx.args.id", "SELECT * FROM <name-of-table> WHERE id=$ctx.args.id"]
}

Sample mutation response VTL with support for handling AWSDateTime

#set ( $index = -1)
#set ( $result = $util.parseJson($ctx.result) )
#set ( $meta = $result.sqlStatementResults[1].columnMetadata)
#foreach ($column in $meta)
    #set ($index = $index + 1)
    #if ( $column["typeName"] == "timestamptz" )
        #set ($time = $result["sqlStatementResults"][1]["records"][0][$index]["stringValue"] )
        #set ( $nowEpochMillis = $util.time.parseFormattedToEpochMilliSeconds("$time.substring(0,19)+0000", "yyyy-MM-dd HH:mm:ssZ") )
        #set ( $isoDateTime = $util.time.epochMilliSecondsToISO8601($nowEpochMillis) )
        $util.qr( $result["sqlStatementResults"][1]["records"][0][$index].put("stringValue", "$isoDateTime") )
    #end
#end
#set ( $res = $util.parseJson($util.rds.toJsonString($util.toJson($result)))[1][0] )
#set ( $response = {} )
#foreach($mapKey in $res.keySet())
    #set ( $s = $mapKey.split("_") )
    #set ( $camelCase="" )
    #set ( $isFirst=true )
    #foreach($entry in $s)
        #if ( $isFirst )
          #set ( $first = $entry.substring(0,1) )
        #else
          #set ( $first = $entry.substring(0,1).toUpperCase() )
        #end
        #set ( $isFirst=false )
        #set ( $stringLength = $entry.length() )
        #set ( $remaining = $entry.substring(1, $stringLength) )
        #set ( $camelCase = "$camelCase$first$remaining" )
    #end
    $util.qr( $response.put("$camelCase", $res[$mapKey]) )
#end
$utils.toJson($response)

Using Variable Map

Variable map support is limited and does not differentiate numbers and strings data types, please inject them directly if needed.

Will be escaped properly: null, true, and false values.

{
  "version": "2018-05-29",
  "statements":   [
    "UPDATE <name-of-table> set deleted_at=NOW() WHERE id=:ID",
    "SELECT * FROM <name-of-table> WHERE id=:ID and unix_timestamp > $ctx.args.newerThan"
  ],
  variableMap: {
    ":ID": $ctx.args.id,
##    ":TIMESTAMP": $ctx.args.newerThan -- This will be handled as a string!!!
  }
}

Requires

Author: Serverless-appsync
Source Code: https://github.com/serverless-appsync/serverless-appsync-simulator 
License: MIT License

#serverless #sync #graphql 

Aarna Davis

Aarna Davis

1625055931

Hire Front-end Developer | Dedicated Front-end Programmers In India

Hire top Indian front end developers for mobile-first, pixel perfect, SEO friendly and highly optimized front end development. We are a 16+ years experienced company offering frontend development services including HTML / CSS development, theme development & headless front end development utilising JS technologies such as Angular, React & Vue.

All our front-end developers are the in-house staff. We don’t let our work to freelancers or outsource to sub-contractors. Also, we have a stringent hiring mechanism to hire the top Indian frontend coders.

For more info visit: https://www.valuecoders.com/hire-developers/hire-front-end-developers

#front end developer #hire frontend developer #front end development company #front end app development #hire front-end programmers #front end application development

Front End Development Best Practices To Follow

This is image title
As someone from a non-tech background, you might not understand the complexities of front-end development. What we see on our mobile screens or PCs is a mere fragment of intricately woven code. But if you are looking forward to developing an application, you would have to dive in and know the scopes found in front-end development with the advent of new technologies, tools, and frameworks.

In this blog, we will help you understand the best practices of Front-end development and the burgeoning trends that would help you ensure the quality development of your digital products. Learn about the future of web development is here.

GUI Development Best Practices: UX And UI

Before you start the development work, it is essential to discuss the user experience and user interface of your product. The front-end of any software is the only thing that interacts with your users. Moreover, it is important that you make incredible contact with your users. It is not just about the smoothness; also about navigation; you have to make things as simple as possible for your users to interact with your product.

User Experience Vs. User Interface

Most people confuse user experience and user interface to be one and the same thing. But they cannot be more wrong. User experience and user interface work together; they are different components of your product’s front end? Here are a few things which they share and that differentiate them.

  1. User Experience
    Starting with UX, it is a term coined by Don Norman, and when he did that, he did not contextualize it to any kind of software product. It was used for multiple disciplines, including marketing, graphical & industrial design, interface, and engineering.
    This is image title
    In software development, it focuses on building user-centric processes that optimize the user interaction with the product. The best practices of delivering a great user experience include; researching customer behavior, understanding the context in which the audience takes action, and creating a systematic vision for the target audience to reach its goal.Use your newfound knowledge to develop an actual graphic design. It needs to be analytical and action-provoking. A good UX designer would always understand the way a user interacts with your product.

  2. User Interface
    User experience helps you define the user interface design. It would include the components that make up the entire experience of the product. Additionally, it includes toggle, background, fonts, animation, and other graphical elements.
    This is image title
    If the user experience is about how the user interacts with your products, the user interface is about giving them the channels to interact with your product. So, the best practices of creating a rewarding user interface are; following brand style guidelines, intuitive design, support for various screen sizes, and effective implementation.

Front-End Development Best Practices: Design To Development

Once you are done with the design part, it is time to dive into development. The process includes turning the graphical assets into a functioning product. There are various approaches that the software community uses, but the most rewarding one is object-driven design and development as it improves the user experience tenfold.

The object-driven approach allows you to design graphical assets that follow the same design and pattern. Also, it allows you to translate the components for faster delivery and a cohesive UX and UI experience across products and platforms.

The design to development process allows you to build interfaces that include layouts, colors, typography, spacing, and more. Front-end development teams are required to work according to the guidelines of the target platform, and they must focus on the UI and UX peculiarities of product development. It is likely that you may face some temporary technical challenges during development and implementation.

It is a trend to automate the front-end development of software with Zeplin or Avocode. The tools ensure access to the updated design, accurate specs and automatically generate the code snippet that allows faster delivery. Learn about the right process of web development here.

  1. Frontend CSS Frameworks
    Depending on the project specification, a software development company would suggest you the right toolsets. The most popular front-end CSS frameworks are Bootstrap, Foundation, Material Design; they are known for increasing the speed of development and come with ready-to-use components that make it easy to replace the manual code and comply with responsive web design standards.

Here is a list of popular front-end development technologies

  • React
  • Angular
  • Vue.JS
  • Knockout and Backbone

Continue Reading

#front end web development #how to learn front end development #how to master front end development #how to practice front end development #is front end development easy

黎 飞

黎 飞

1656984600

如何将函数从 C++ 导出到 React Native

今天,我继续分享我在 Native Module 和 C++ 方面的经验。

由于我们将看到很多为移动平台编写的 C/C++ 库,因此我们需要将它们实现到我们的 iOS 或 React Native 应用程序中。这就是为什么我想写一篇关于如何将一个函数从 C++ 导出到 React Native 的文章,它易于理解并且为初学者节省了时间。我将从一个新的 react native 应用程序开始

1.新建一个react native app,打开你的终端运行

npx react-native init NativeModules

2. 打开 Xcode 并导航到 NativeModules/ios/NativeModule.xcworkspace

3. 在 C++ 端工作

创建一个新的 C++ 文件并命名Cpp_to_RN.cpp

当我们创建一个新的 C++ 文件时,Xcode 会Cpp_to_RN.hpp 为我们创建一个头文件

首先,打开“ Cpp_to_RN.hpp文件,并创建一个包含没有主体的函数的类。

#ifndef Cpp_to_RN_hpp
#define Cpp_to_RN_hpp#include <stdio.h>
#include <string>class Cpp_to_RN {
public:
    std::string sayHello();
};#endif /* Cpp_to_RN_hpp */

然后打开Cpp_to_RN.cpp文件,写一个简单的函数“ sayHello()

#include "Cpp_to_RN.hpp"
std::string Cpp_to_RN::sayHello(){
    return "Hello from CPP";
}

4. 处理包装 C++ 文件。

包装 C++ 文件并将它们导出到 IOS (swift) 端

一个。创建一个Objective C文件并命名Cpp_to_RN.m

重命名Cpp_to_RN.m Cpp_to_RN.mm

湾。打开WrapCpp_to_RN.mm 文件并编写将包装sayHelloC++ 文件中的函数的正文内容。

#import <Foundation/Foundation.h>
#import "WrapCpp_to_RN.h"
#import "Cpp_to_RN.hpp"@implementation WrapCpp_to_RN- (NSString *) sayHello {
  Cpp_to_RN fromCPP;
    std::string helloWorldMessage = fromCPP.sayHello();
    return [NSString
            stringWithCString:helloWorldMessage.c_str()
            encoding:NSUTF8StringEncoding];
}
@end

C。创建头文件并命名WrapCpp_to_RN.h

将函数导出wrapSayHello到 Swift 文件

#import <Foundation/Foundation.h>
@interface WrapCpp_to_RN : NSObject
- (NSString *) wrapSayHello;
@end

5. 在 iOS (Swift) 端工作

将 C++ 函数导出到 React Native

一个。创建一个 Swift 文件并命名SendCpp_to_RN.swift

注意:Xcode 会要求我们为我们创建一个NativeModules-Bridging-Header.h文件。

创建一个类SendCpp_to_RN并将其声明为NSObject

#import <Foundation/Foundation.h>
@interface WrapCpp_to_RN : NSObject
- (NSString *) wrapSayHello;
@end

编写一个函数requiresMainQueueSetup()来防止我们运行应用程序时出现警告

#import <Foundation/Foundation.h>
@interface WrapCpp_to_RN : NSObject
- (NSString *) wrapSayHello;
@end

编写一个函数来包装WrapCpp_to_RN()fromWrapCpp_to_RN.mm

import Foundation@objc(SendCpp_to_RN)
class SendCpp_to_RN : NSObject {
    
  @objc static func requiresMainQueueSetup() -> Bool {
        return false
    }
  
  @objc func fromCpp(_ successCallback: RCTResponseSenderBlock) -> Void {
    successCallback([NSNull(), WrapCpp_to_RN().wrapSayHello() as Any])
    }}

湾。将 Swift 文件中的包装函数导出到 React Native

创建一个 Objective C 文件以导出 Swift 类及其函数,使用Callback

#import <React/RCTBridgeModule.h>
#import <Foundation/Foundation.h>
#import "UIKit/UIKit.h"
@interface RCT_EXTERN_MODULE(SendCpp_to_RN, NSObject)RCT_EXTERN_METHOD(fromCpp:(RCTResponseSenderBlock)successCallback)@end

C。将 Swift 连接到 React Native,打开NativeModules-Bridging-Header.h 文件

#import <React/RCTBridgeModule.h>#import <React/RCTViewManager.h>#import "WrapCpp_to_RN.h"

6. 在 React Native 方面工作

调用 Swift 类及其函数

import React from 'react';
import {StyleSheet, Text, View, NativeModules, Button} from 'react-native';const App = () => {
  const onPress = () => {
    const {SendCpp_to_RN} = NativeModules;
    SendCpp_to_RN.fromCpp((_err, res) => console.log(res));
  };
  return (
    <View style={styles.container}>
      <Text> Practice !</Text>
      <Button title="C++ to React Native" color="#841584" onPress={onPress} />
    </View>
  );
};
const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
});
export default App;

我们完成了,只需运行应用程序

react-native run-ios

或者只需单击 Xcode 上的“运行”按钮,看看我们做了什么。

希望我的文章对您有所帮助,感谢您的阅读时间。

 来源:https ://betterprogramming.pub/native-modules-export-c-function-to-react-native-for-beginners-77e89934b210

#cpp #cplusplus #react 

Léon  Peltier

Léon Peltier

1656979200

Comment Exporter Une Fonction De C++ Vers React Native

Aujourd'hui, je continue à partager mon expérience avec le module natif et C++.

Comme nous verrons beaucoup de bibliothèques C/C++ écrire pour les plates-formes mobiles, nous devons les implémenter dans notre application iOS ou React Native. C'est pourquoi je souhaite écrire un article sur la façon d'exporter une fonction de C++ vers React Native, ce qui est facile à comprendre et fait gagner du temps aux débutants. Je vais commencer avec une nouvelle application native réactive

1. Créez une nouvelle application native React, ouvrez votre terminal et exécutez

npx react-native init NativeModules

2. Ouvrez Xcode et accédez à NativeModules/ios/NativeModule.xcworkspace

3. Travailler du côté C++

Créez un nouveau fichier C++ et nommez-leCpp_to_RN.cpp

Lorsque nous créons un nouveau fichier C++, Xcode créera un fichier d'en-tête Cpp_to_RN.hpp pour nous

Tout d'abord, ouvrez le fichier " Cpp_to_RN.hpp" et créez une classe qui inclut une fonction sans le corps.

#ifndef Cpp_to_RN_hpp
#define Cpp_to_RN_hpp#include <stdio.h>
#include <string>class Cpp_to_RN {
public:
    std::string sayHello();
};#endif /* Cpp_to_RN_hpp */

Ouvrez ensuite le Cpp_to_RN.cppfichier et écrivez une fonction simple " sayHello()"

#include "Cpp_to_RN.hpp"
std::string Cpp_to_RN::sayHello(){
    return "Hello from CPP";
}

4. Travail sur l'encapsulation du fichier C++.

Pour envelopper les fichiers C++ et les exporter vers le côté IOS (swift)

un. Créez un fichier Objective C et nommez-leCpp_to_RN.m

Renommez le Cpp_to_RN.m en Cpp_to_RN.mm

b. Ouvrez le WrapCpp_to_RN.mm fichier et écrivez le contenu du corps qui encapsulera la fonction sayHelloà partir du fichier C++.

#import <Foundation/Foundation.h>
#import "WrapCpp_to_RN.h"
#import "Cpp_to_RN.hpp"@implementation WrapCpp_to_RN- (NSString *) sayHello {
  Cpp_to_RN fromCPP;
    std::string helloWorldMessage = fromCPP.sayHello();
    return [NSString
            stringWithCString:helloWorldMessage.c_str()
            encoding:NSUTF8StringEncoding];
}
@end

c. Créez un fichier d'en-tête et nommez-leWrapCpp_to_RN.h

Exporter la wrapSayHellofonction vers le fichier Swift

#import <Foundation/Foundation.h>
@interface WrapCpp_to_RN : NSObject
- (NSString *) wrapSayHello;
@end

5. Travailler du côté iOS (Swift)

Pour exporter la fonction C++ vers React Native

un. Créez un fichier Swift et nommez-leSendCpp_to_RN.swift

Remarque : Xcode nous demandera de créer un NativeModules-Bridging-Header.hfichier pour nous.

Créez une classe SendCpp_to_RNet déclarez-la commeNSObject

#import <Foundation/Foundation.h>
@interface WrapCpp_to_RN : NSObject
- (NSString *) wrapSayHello;
@end

Écrire une fonction requiresMainQueueSetup()pour empêcher l'avertissement lorsque nous exécutons l'application

#import <Foundation/Foundation.h>
@interface WrapCpp_to_RN : NSObject
- (NSString *) wrapSayHello;
@end

Ecrire une fonction pour envelopper le WrapCpp_to_RN()fromWrapCpp_to_RN.mm

import Foundation@objc(SendCpp_to_RN)
class SendCpp_to_RN : NSObject {
    
  @objc static func requiresMainQueueSetup() -> Bool {
        return false
    }
  
  @objc func fromCpp(_ successCallback: RCTResponseSenderBlock) -> Void {
    successCallback([NSNull(), WrapCpp_to_RN().wrapSayHello() as Any])
    }}

b. Exporter une fonction wrap dans un fichier Swift vers React Native

Créez un fichier Objective C pour exporter la classe Swift et sa fonction à l'aide deCallback

#import <React/RCTBridgeModule.h>
#import <Foundation/Foundation.h>
#import "UIKit/UIKit.h"
@interface RCT_EXTERN_MODULE(SendCpp_to_RN, NSObject)RCT_EXTERN_METHOD(fromCpp:(RCTResponseSenderBlock)successCallback)@end

c. Connectez Swift à React Native, ouvrez le NativeModules-Bridging-Header.h fichier

#import <React/RCTBridgeModule.h>#import <React/RCTViewManager.h>#import "WrapCpp_to_RN.h"

6. Travailler du côté React Native

Appelez la classe Swift et ses fonctions

import React from 'react';
import {StyleSheet, Text, View, NativeModules, Button} from 'react-native';const App = () => {
  const onPress = () => {
    const {SendCpp_to_RN} = NativeModules;
    SendCpp_to_RN.fromCpp((_err, res) => console.log(res));
  };
  return (
    <View style={styles.container}>
      <Text> Practice !</Text>
      <Button title="C++ to React Native" color="#841584" onPress={onPress} />
    </View>
  );
};
const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
});
export default App;

Et nous avons terminé, il suffit de lancer l'application

react-native run-ios

Ou cliquez simplement sur le bouton "exécuter" sur Xcode et voyez ce que nous avons fait.

J'espère que mon article vous sera utile, merci pour le temps de lecture.

 Source : https://betterprogramming.pub/native-modules-export-c-function-to-react-native-for-beginners-77e89934b210

#cpp #cplusplus #react