What is Dash? 

According to the official documentation, “Dash is the original low-code framework for rapidly building data apps in Python, R, Julia, and F# (experimental).”

Dash was written on top of Plotly.js and React.js, making it an ideal tool for building and deploying data apps with customized user interfaces. Dash works by abstracting away all the technologies and protocols needed to build a full-stack web app that includes interactive data visualization through a couple of simple patterns.

Dash is so simple that it will take you less than 10 minutes to bind a user interface to your code.

An app developed with Dash is rendered on a web browser. It can be deployed to VMs or Kubernetes clusters to then share it through URLs. The fact that Dash is rendered on the web, means it’s also inherently cross-platform and mobile-ready!

All of these features make Dash quite popular; the framework is currently downloaded 600,000 times each month.

What can be done with Dash? 

Well, Dash is just the pencil and you are the actual artist. However, to give an idea of what this framework can help you create, check out the Dash app gallery.

This is my personal favorite.

Building your first Dash graph

Now that you have some context, let’s get to it and build a Dash graph.

Install Python’s Dash

First, you’ll need to create a virtual environment and activate it.

virtualenv dashvenv

source ./dashvenv/bin/activate

Then, install Dash.

pip install dash

pip install jupyter-dash

pip install pandas

You can try running one of Dash’s ready-made examples; just create an app.py file and copy one of the following examples. For this article, we’ll be using the one below.

gist

Link: script

Test the installation

Now, run the example and see how it works. 

# Run this app with `python app.py` and

# visit http://127.0.0.1:8050/ in your web browser.

Change the example

Dash includes a hot-reloading feature that is activated by default when running an app with app.run_server(debug=True). Therefore, Dash will automatically refresh your browser whenever you make a change to your code.

Give it a try by changing the title “Hello Dash” in your application or by changing the data on the x- or y-axis. Your app should auto-refresh with your changes.

The 3 pillars of Dash

We’ve shown you how to create an example graph app using Dash. Now it’s time to dig a little deeper into Dash itself by looking into three aspects of this framework: Dash components, plotly graphs, and Dash callbacks.

Dash components

dash_html_components (known as dash.html as of Dash version 2.0) includes a component class for each HTML tag, as well as keyword arguments for every HTML argument.

Dash provides supercharged components to help you create interactive user interfaces. You can find a core set of components (that are written and maintained by the Dash team) in the dash-core-components library.

When it comes to producing Dash apps, we’d advise you to manage the Dash Core Components styling and layout with Dash Enterprise.

Plotly graphs

Plotly’s Python graphing library helps you create interactive graphs with publication quality. The library includes a wide variety of examples showing you how to produce different plots, charts, histograms, heatmaps, and more. Plotly.py is free and open-source; this means you can view the source, report issues or even contribute on GitHub!

Dash callbacks

Dash apps use callback functions (i.e.: functions that are automatically called by Dash whenever an input component’s property changes), in order to update some property in another component (i.e.: the output).

Creating your own Python’s Dash app

Now that we’ve gone over the basics, it’s time to get serious.

We will use a Covid-19 public dataset to create a world map with the pandemic evolution over time.  

First, you need to pull the data as CSV and create a pandas dataframe that includes just the relevant information.

Then, create a Dash component that contains the following:

• DIV
• H1 header
• DROPDOWN slct_year, which will contain the dates of our dataset
• DIV output_container, a div that will display a user-friendly message 
• A graph of the world heat map

To do this, you’ll have to re-format the dates in an object to create the Dash dropdown component.  

Then, you can create the app layout with your Dash components.

Now, you’ll need to create a callback function that will have the dropdown value as input, and the output_container and the map to update the information with the given input.

Then, you can define what to do with the input given value, that is, the selected year.

You then create the friendly message and the choropleth graph.

You can find more information about this plotly.express.choropleth here.

The data frame will be filtered by date; you can go ahead and add a continent filter, or add a selector for different values, such as vaccination percentage or tests performed.

If everything goes well, you should be able to run our app and see it working.

You can find the repository for this project here.

Final thoughts on data analytics using Python Dash framework

As we can see, amazing apps can be built with small pieces of code by using Python Dash framework. This is definitely a powerful tool for every developer to have in their toolkit. Moreover, as we all know, when it comes to building something complex, patience and practice are the keys to success. So start practicing!

The post Data analytics using Python’s Dash framework appeared first on asap developers.

What is BDD or Behavior Driven Development?

BDD is a work methodology for software teams that closes the gap between those working on the business side of a project and those on the technical side. This is achieved by:

• Encouraging collaboration across roles to build a shared understanding of the problem to be solved
• Working in rapid and small iterations to increase feedback and the value flow
• Producing system documentation that is automatically checked against the system’s behavior

All of this is done by focusing collaborative work around concrete, real-world examples that illustrate how we want the system to behave. Those examples guide developers from concept through to implementation in a process of continuous collaboration.

Why Use Flutter with BDD

We thought Teresa Wu made a perfect point in her Mobile London talk on How to implement BDD in a Flutter project, so we’ll let her speak for us as to why or when to use BDD:

“Given the mission to get things done right and in time

And mitigate creating tech debt for the future self 

When working with the new project

Then we use BDD”

BDD and agile

If your team is using agile methodologies already, it can aid you in planning your work in small increments of value like user stories. Keep in mind that BDD doesn’t replace your existing agile process, it just enhances it.

BDD could be compared to a set of plugins for your existing process that will help your team be more capable to deliver on the promises of agile. In other words, BDD will help your team produce timely, reliable releases of working software that meet your organization’s requirements.

Flutter with BDD

Building our first Flutter App with BDD

Let’s start by building our very first Flutter App using BDD. 

We’ll assume that you have your development environment working and that you are able to see the start template app. We’ll be using the web stable version of Flutter.  

As we are using BDD, we’ll be focusing on the sometimes regrettably ignored test folder. Files in this folder start compiling just fine, but as the project grows, most developers break its files and end up deleting one or more files, or even the entire folder. 

This has a logical explanation. Writing tests is not an easy task; you need to spend time learning what unit, widget and integration tests are and how they work before you can write useful tests.

But, in this article, we will keep things simple following the methodology of KISS software development. 

Write features 

We’ll write our test in a natural language by creating a *.feature file inside the test folder. Let’s say you’re testing the default Flutter counter app, then the content might be:

Link: script

Add the dependency

To make a widget test with this file, we’ll install the dependencies:

<code>
dev_dependencies:
build_runner:
bdd_widget_test: <put the latest version here>
...
</code>

Generate the test files

Now, ask built_value to generate Dart test files for you. You can do this with the following command:

<code>
flutter packages pub run build_runner watch --delete-conflicting-outputs
</code>

Run tests

Now, it’s time to run the test. You can do it from your IDE or by running the following:

<code>
flutter test
</code>

All tests have passed, congrats! You can now push your changes. 

Let’s add a more complex test to test the current project template’s functionality.

Link: script

When you save your changes on the .feature file, the test file in Dart will be updated with the content of the new test. Go ahead and run it.

Green status again! Go ahead and push it.

Now, let’s make use of the BDD circle and add a test for a new functionality we will implement. 

Let’s say we want a button that, when pressed, decreases the counter. 

Go ahead and write the scenario:

Link: script

Now, if you check the Dart file, it should have the new test for the given scenarios. 

Try to run them, just to see them fail. We are in the red status of the BDD circle. Now, let’s add the functionality. 

Try replacing your current Action button with a stack of two buttons:

Link: script

You can write the _decrementCounter function on your own so that if you run your test, it passes.

Final thoughts on Flutter with BDD 

Congrats! You are on your way to following the BDD process in Flutter development! 

Here is the entire code for you to check out. 

Keep it flowing and don’t forget, “Every large system that works started as a small system that worked.”

The post Flutter with BDD appeared first on asap developers.

According to RedHat, “CI/CD is a method to frequently deliver apps to customers by introducing automation into the stages of app development. The main concepts attributed to Python for CI/CD are continuous integration, continuous delivery, and continuous deployment.”

Now that we know what we’re talking about, let’s see how it all works.

How to build a CI/CD pipeline with Python 

We will be building a small CI/CD pipeline in 7 steps as you’ll see below. Let’s get started!

1. Write a Python program 

First, we need a small software that will be deployed to the cloud. We will build a movie name generator, but it could also be a movie recommendation system

To do this, first create a new directory (let’s call it “python-cicd”). 

Inside this directory, create another directory called “generator” and, in this directory, save two files: 

• An empty file called “__init__.py”
• And this script file called “generator.py”

Link: script

You should be able to run this Python script from the command line inside the “generator” directory we mentioned above; try it and check the movie results.

python-cicd$ python generator/generator.py
Honor With Men'S Legacy
python-cicd$ python generator/generator.py
Construction Against Directors


Looks good! Now go ahead and add your own words to make more original movie titles. 

2. Automate testing

Many programmers choose to test the code they are writing manually by calling the piece of code they are developing, then printing the result to the console and, finally, visually scanning the output for correctness. This works for simple tasks but poses some problems:

• When the output becomes too large, it gets harder to spot errors.

• When the programmer gets tired, it is easy to miss subtly incorrect output.

• When the implemented feature becomes larger, we tend to miss bugs we might have introduced in parts that were “tested” earlier.

• Because the informal test scripts tend to be only useful for the programmer who wrote them, this means it is of no use to other developers.

These issues are the reason unit testing was invented. Through unit testing, you write sample calls to pieces of code and compare the return value to the expected value.

This comparison is generally done in a way that gives little or no output when the test passes and very obvious output otherwise. You can use a test harness to run tests from several test scripts and report just the errors and a statistical summary of the passed tests.

We need some additional tools to run the unit tests we are going to write. These are available as Python for CI/CD packages. To install them, you should use a tool called virtualenv.

python-cicd$  virtualenv venv
Honor With Men'S Legacy
python-cicd$ source venv/bin/activate
(venv) python-cicd$


Next, create a new file called “requirements.txt” that lists the pytest dependency:

pytest==6.2.4


To download the dependencies listed in the requirements file, you’ll need to execute the “pip” command:

(venv) python-cicd$ pip install -r requirements.txt


Create a new folder called “test” and put two files inside: 

• An empty file called “__init__.py”
• And this script file called “test_generator.py”

Link: script

Then, run the test file.

(venv) python-cicd$ python -m pytest -v test/test_generator.py


You should see them passing.

3. Push your code to GitHub

We chose GitHub for this article, but you can use virtually any Git provider. Let’s start by logging into GitHub (you should get an account first if you don’t have one already) and then create a new public repository called “python-cicd”.

Inside your project directory, create a new file called “.gitignore” containing the following:

venv
__pycache__
test/__pycache__/
generator/__pycache__/


This will prevent Git from adding the virtualenv or any IDE file that can cause us problems later to our repo. Now you should initialize Git locally and push your code to GitHub:

[python-cicd] $ git init
[python-cicd] $ git add *
[python-cicd] $ git commit -m "Initial commit"
[python-cicd] $ git remote add origin
git@github.com:/python-cicd.git
[python-cicd] $ git push -u origin master


4. Setup GitHub Actions CI to continuously run your automated tests

Go to your GitHub repository, and create the new workflow in the actions tab.

This should commit a YAML file into your repository. In the .github/workflows folder, your YAML file must be similar to this: 

Link: script

Remember to change the Python version to the one you are using in your project.

Then, try it out by making any changes to your code and pushing them; it should start a build process on the actions tabs that looks something like this: 

Congratulations! You have successfully built your very first continuous integration pipeline

5. Setup Wily to continuously check your code quality

Wily is a python tool that helps you keep track of the maintainability of your project, in order to write simpler and more maintainable Code.

In each build, we will show the evolution of your maintainability score and other metrics such as lines of code or cyclomatic complexity. 

First, we need to install Wily. 

(venv)[python-cicd] $ pip install wily


Add Wily to your requirements.txt.

(venv)[python-cicd] $ pip freeze > requirements.txt


Then, we will add Wily to the GitHub actions pipeline by editing our YAML file. Add a new step to our pipeline file, called “Wily”, to the end of your file. 

Link: script

Push your changes and check the GitHub actions execution; you should see something similar to this output:

6. Turn the Python program into a web app

Great work! We already have a CI pipeline that checks for functionality and quality.

Since we will deploy the software to Heroku as a web app, we first need to write a little Python Flask wrapper around our movie generator to make the program respond to HTTP requests and output HTML.

Add the code below in a file called “app.py” in the root of your project directory:

Link: script

Install Flask.

(venv)[python-cicd] $ pip install flask


Add Flask to your requirements.txt. 

(venv)[python-cicd] $ pip freeze > requirements.txt


You can now run the Flask application locally.

(venv)[python-cicd] $ python app.py
* Serving Flask app 'app' (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: off
* Running on all addresses.
WARNING: This is a development server. Do not use it in a production deployment.
* Running on http://192.168.1.6:5000/ (Press CTRL+C to quit)


Open the local host location and you should see the app running smoothly. 

Refresh it a few times, and check out the movie title ideas.

Push your changes and see Wily’s magic in action. 

7. Deploy the web app to Heroku

Heroku is a cloud platform used to host small and scalable web applications. It offers a free plan so go to https://signup.heroku.com and sign up if you haven’t already done so.

Once you are in Heroku, sync your GitHub repository to the Heroku CLI, so, whenever you push new changes to your code in GitHub, Heroku will build and deploy your app automatically.

Start by creating a new app in Heroku and, in the deployment method option, choose “connect to GitHub.”

You may have to log into GitHub if you haven’t already, and select the repo for the project. 

Heroku serves Python apps with Gunicorn “Green Unicorn”, which is a Python web server that is simply implemented, light on server resources, fairly fast, and broadly compatible with a number of web frameworks.
First, we need to install it.

(venv)[python-cicd] $ pip install gunicorn


Add Gunicorn to your requirements.txt.

(venv)[python-cicd] $ pip freeze > requirements.txt


In the root folder of your project, create a “Procfile” and write the following code:

web: gunicorn wsgi:app


Then, create a “runtime.txt” file and include the Python version you are using; in our case, it’s version 3.6.14.

python-3.6.14


Create a “wsgi.py” file and insert the following code.

from app import app as application
app = application
if __name__ == "__main__":
app.run()


Commit your changes and push them to Heroku. 

git push heroku master


If everything went well, you should see the movie generator rocking on the cloud! 

Congrats! Now, with every change to your code, you will automatically run tests, check maintainability and deploy to Heroku! If you are facing any issues during deployment using Python for CI/CD, feel free to contact us, or check Heroku’s official Python page.

The post Python for CI/CD appeared first on asap developers.

Flutter’s web support has brought about innovations and makes highly sophisticated apps with hardware-accelerated 2D and 3D graphics and flexible layout and paint APIs possible. It offers an app-centric framework that takes full advantage of everything the modern web has to offer.

Moreover, Flutter makes it easier to build responsive screens that adapt to different devices and appropriately fit users’ screens, all in one code base.

The Flutter UI toolkit is specially useful on three particular app scenarios:

• Progressive web apps (PWAs) that combine the web’s reach along with the capabilities of a desktop app.
• Single page apps (SPAs) that load once and transmit data to and from internet services.
• Existing Flutter mobile apps that are being migrated to the web, enabling shared code for both experiences.

Here you can check Flutter’s power on the web. 

But, most valuable of all, is that this power comes with less weight and, therefore, with, native performance. This is a major plus since native performance leads to better user experience and we know for a fact this correlates with user retention. 

Flutter Create 

Flutter Create is an annual contest that challenges developers to build interesting, inspiring, and beautiful apps with Flutter using 5kB or less of Dart code.

Just to put things into perspective,  5kB is equivalent to:

• Less than half a second of your average music file. A MP3 file is usually encoded at 128kbps (kilobits/sec). That’s 128/8 = 16 kilobytes/second. So 5kB is 0.3125s of a typical MP3 file.

• Less than 0.05% of the size of the HTML specification. Less than 5% of the size of the HTML specification’s table of contents, even.

• The size of an 80×60 original image encoded in GIF format.

But, what can be built within this size restriction? Can something beautiful be so small? Check out this video and prepare to be surprised. 

Isn’t it amazing? We find it impressive for sure. 

The winners: best Flutter apps

The 2020 winners have not been announced yet and we are looking forward to seeing what the community builds!

Meanwhile, let’s take a look at the 2019 winners: 

Grand Prize Winner: Compass by Zebiao Hu

This Flutter app uses the magnetometer, accelerometer, location sensors in order to get a user’s current direction, location, weather, temperature, humidity, etc. When you scroll up, it shows a globe that users can rotate to get real-time weather data.

Visual Beauty Winner: Relax by Erin Morrissey

This meditation app displays rain, forests, sunsets, and oceans with their corresponding sounds. Users can choose between four nature sounds and it alternates through related images while the sounds are playing.

Code Quality Winner: Pocket Piano by Rody Davis

This is a piano built for Web, iOS and Android. Pocket Piano gives you the option to change the octave (by sliding to the left or right), as well as the key width. You can also toggle labels on the keys and play any note (or notes) by tapping. The piano also fully supports semantics for screen reader users. Here is the repo. 

Overall Execution Winner: TimeFlow by Fabian Stein

Timeflow is a timer that displays a sphere that shatters into pieces and slowly reassembles in one, two, or three minutes, as selected (you can see the reassembly in the video above). 

Other Submissions

Judging is no easy task, here we’ll list our top 5 apps. You can find all submissions here.

Shooter Game

This simple shooter game was created using Flutter and Flare with no game engine whatsoever.

Elements-App

Elements lets you browse the elements of the periodic table!

This Flutter app was developed specially for the Flutter Create 2019 contest. In addition to showing you the various elements, it also includes helpful snippets of information about each one.

Elements is a cross-platform app that can run both on Android and iOS.

Lifenticon

Lifention is a combination of Game of Life and Identicon.

This app lets you assess how your name would do in Conway’s Game of Life by turning it into an Identicon—that is, a visual representation of a hash value—and using it as the seed of the system.

Flutter memory game

Memory is based on the classic card game. It starts by showing all the cards face down. Two cards are then flipped over each turn. The object of the game is, of course, to turn over pairs of matching cards.

Memory has been tested on both simulated and physical Android devices as well as simulated iOS devices.

FidgetDice

FidgetDice is an App that acts as a fidget-cube.

Final thoughts on best Flutter apps under 5kB of Dart Code

As you can see, beautiful things can be built with Flutter, even with a restrictive size limitation. We can’t wait to see the 2020 contest results! 

The post Best Flutter apps under 5kB of Dart code appeared first on asap developers.

Why Flutter e-commerce? 

Why is it worth it to consider investing in Flutter development, even when it means your whole team has to learn an entirely new programming language called Dart? Well, everyone who is working in the tech industry knows that the learning process never stops. You are never fully satisfied with what you know, and checking out new technologies is certainly a competitive advantage, if not a business survival issue. 

When it comes to e-commerce, Flutter is certainly innovative and it has some great advantages for developers which can lead to excellent results in record time. Here are some of them:

• FAST DEVELOPMENT

Bring your app to life in milliseconds with stateful hot reload. Flutter’s rich set of fully-customizable widgets helps you build native interfaces in minutes.

• BEAUTIFUL UI

Quickly ship features focusing on native end-user experience. Its layered architecture allows for full customization, resulting in incredibly fast rendering as well as expressive and flexible designs.

• NATIVE PERFORMANCE

Flutter’s widgets incorporate all critical platform features such as scrolling, navigation, fonts and icons. On top of that, your code is compiled to native ARM machine code through Dart’s native compilers.

• WIDGET CUSTOMIZATION AND EXTENSION

Google Flutter also gives you the option to customize a widget’s default behavior. To do this, you just need to create a pull request to the class you are trying to modify and add the property or the behavior you need. This will get you an extended widget and a new way to customize your app.

• APP TEMPLATES

Flutter includes open-source templates that everyone can use freely. These templates include design implementation for hotel bookings, design courses, fitness sites, and a custom drawer and all of these can be of help to any Flutter developer.

• OPEN-SOURCE

Open-source is the future. Lately, web, mobile, and cloud solutions are built predominantly on open-source infrastructure. In some cases, data and analytic solutions are actually only available as an open-source option.

• DEBUGGING

There’s plenty of tools and features to help you debug Flutter applications. Some available tools include DevTools, Android Studio/IntelliJ, and the VS Code built-in source-level debugger.

• TESTING

If you want to have the same app available on two platforms, Flutter assures less testing! The quality assurance process can be faster as there is only one codebase. This means the developers write automatic tests only once.

Flutter allows you to do all of the following types of testing:

• Unit tests to test a single function, method, or class.
• Widget tests (in other UI frameworks referred to as “component tests”) to test a single widget.
• Integration tests to help you test all of your app or a large part of an app.

• PORTABILITY 

Flutter apps are able to run on pretty much any device with a screen. There are Flutter apps available for Windows, Linux and macOS, so you can take full advantage of this tool no matter your choice of operating system. (The Flutter dev team has also recently released Flutter 2.0, which includes stable web development.)

PORTABILITY

Yes, we are doubling down on this point as it is a huge advantage. With just one Dart codebase, you can deploy apps for Android and iOS in the mobile market, for Windows, Linux and macOS in the desktop market, and you can build mobile-first progressive web apps for the great World Wide Web. Isn’t that incredible? 

 FLUTTER E-COMMERCE APP TEMPLATES

We finally reached the core of this article: Flutter templates. These are key when it comes to the time-to-market factor, because the templates include a basic purchase flow for your e-commerce project, with professional designs and, sometimes, even more than the basic flows, saving you lots of time.

So, here is a list of the most beautiful e-commerce templates, built with Dart, all easily customizable and adaptable to your specific purpose

1-FluxStore

Available features

• Compatible with top e-commerce frameworks: it includes full integration with WooCommerce, Magento, Opencart and Shopify
• Full e-commerce features: dynamic product variants, order tracking, refunds, checkout process, order notes, wishlists and address management.
• Powerful user settings: the ability to enable push notifications, view wishlists, order history, rate the app on the app stores, include dark themes and a smart chat setting as well as switch languages
• Push notifications via Firebase and message history are supported
• Google Analytics makes it easy to track users online as well as the number of registrations via Firebase in realtime
• Easy customization and while-labeling: supports full customization by getting the full source code package, design assets and free extra API.
• Offline image caching: you can speed up the loading performance with the caching image offline method.
• Messenger, WeChat, Whatsapp… and even Intercom service support.

2-Treva-Shop

E-commerce UI kit features:

• Clean code comments in all code
• Support multiple languages
• Cleanly designed
• Use of the animation controller
• Responsive design for any and all devices and screens
• Easily customizable layout

3-AirMart

Technical features

• Clean code with extracted Flutter widgets
• Implementation of Rive animations
• Uses the List View builder for all lists
• Ready to back end integrations
• Clear and smart UI/UX
• Ready navigation and business logic
• Fully customizable templates (colors, fonts, sizes, borders, paddings, margins, etc.).
• Easily change colors
• Easily connect any customize fonts
• Easily change size and layout
• Smooth (sliver) animations

4-Foodie

Food delivery features:

•  Clean code comments in all code
•  Clean design
•  Use of the animation controller
•  Responsive design for any and all devices and screens
•  Easily customizable layout

5-Free open-source e-commerce template

Features:

• Minimalist design
• Clean and structured code
• Reusable components

Final thoughts on Flutter e-commerce in 2021

Considering all of the above, we believe Flutter is a very powerful technology that has great potential applications for e-commerce. It has the necessary tools and libraries to easily help you build your business all at once—for mobile, web and desktop—, and give more value to your customers. No matter whether you are a passionate UX/UI designer, an advanced mobile developer, or a newbie web developer, you will enjoy working with Flutter, and it will probably save you a significant amount of time. It’s certainly a game changer in the e-commerce business, and it can give your business the competitive advantage it needs.

The post Flutter e-commerce in 2021 appeared first on asap developers.

The most common and smartest way for e-commerce websites to display relevant items to their clients is to use an automated system. This system will be in charge of calculating the probability of similarity between items or user preferences. These systems are called recommendation systems, recommender systems or recommendation engines. A recommender system is one of the most well-known applications of data science and machine learning. In this article, we will go over Python Recommendation Systems.

In fact, almost every major tech company has applied them at some point. Amazon recommends you products, Spotify recommends you music, Google recommends you search results, and YouTube recommends you videos. It is such a common practice that, in 2009, Netflix offered a million dollars to anyone who could improve the accuracy of its movie recommendation system by 10%. 

These systems help us with The Paradox of Choice, a known problem that is caused by the rapid increase in the amount of data and the effects of this abundance: managing the information becomes more difficult and this can lead to information overload.

Recommender systems have great commercial importance; they have changed the way websites communicate with their users, increasing interaction to provide a richer experience by autonomously identifying recommendations for individual users based on the user’s past purchases and searches, as well as their behavior.

What are the types of python recommendation systems? 

Recommendation systems can be classified into 3 types:

Simple recommenders

This is the type of recommender we will build in this article. It offers generalized recommendations to each user, based on each element’s attributes. In a movie recommendation scenario, it will make recommendations to each user based on movie genre, movie rating or movie title. An example of a simple recommender is IMDd’s Top 250.

Content-based recommenders

These recommenders suggest similar items based on a specific one, taking into account each user’s preferences. This system uses item metadata and the general idea behind it is that if a person likes a particular item, they will also like a similar one. This does not involve other users, just each individual’s preferences. Based on what you like, the algorithm will pick items with similar content and recommend them.

It will never recommend products within categories the user has not bought or liked in the past. So, for example, if a user has watched or liked only action movies so far, that’s the only genre the system will recommend.

Collaborative filtering engines

The collaborative filtering algorithm uses user behavior to select the items to be recommended. These systems are widely used and do not require item metadata like their content-based counterparts. There are different types of collaborating filtering techniques and we’ll look at them in detail below.

User-User collaborative filtering

This algorithm finds similarities between users grading a score in the process. Based on this score, it picks the most similar users and recommends products that they have previously liked or bought. Essentially, it generates a prediction for item A based on how other users in the neighborhood rated it.

Item-Item collaborative filtering

In this case, the algorithm computes the similarity between each pair of items. Similar items are identified based on how people have rated them in the past. For example, if Julia, Christian, and Vic have given 5 stars to The Lord of the Rings and Harry Potter, the system identifies the items as similar. Therefore, if someone buys The Lord of the Rings, the system also recommends Harry Potter to them.

Why Python Recommendation Systems?

 You can build this system in virtually any language, but Python certainly takes the most points in this particular field. Python offers readable code for complex algorithms and versatile workflows in machine learning and AI. Python allows you to put all the effort into solving a machine learning problem instead of focusing on the language itself.

Moreover, Python is easy to learn since its code is easy for people to follow, which makes it easier to build models for machine learning. Python is more intuitive than other programming languages. It has many frameworks, libraries, and extensions that simplify the implementation of different functionalities. 

Today, we will be using some of those libraries: 

Scikit-learn: Machine Learning in Python

Scikit-learn offers simple and efficient tools for predictive data analysis. It is accessible to all and reusable in various contexts. It is built on NumPy, SciPy, and matplotlib. Moreover, it’s open-source and commercially available under the BSD license.

Pandas is a data analysis and manipulation tool. It was built on top of the Python programming language. This tool is fast, powerful, flexible, open-source and easy-to-use.

NumPy is the fundamental package for scientific computing with Python. Nearly every scientist working with Python draws on the power of NumPy. With this power comes simplicity: a solution in NumPy is often clear and elegant.

Build a simple movie with Python recommendation system 

We will be working with Jupyter Notebooks, but you can just find the code in this repository; there you’ll find this file and the dataset used in this example. 

According to its website, “Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and explanatory text. Uses include: data cleaning and transformation, numerical simulation, statistical modeling, machine learning and much more.”

First, we will import all the necessary libraries for this lab.

Then, we’ll load the dataset, which we obtained from the IMDb Datasets of all movies uploaded in a certain period; we will use a reduced test dataset just to save computer resources.

title.basics.tsv.gz – Contains the following information for titles, as can be see in IMDb’s website:

• tconst (string) – alphanumeric unique identifier of the title.
• titleType (string) – the type/format of the title (e.g. movie, short, tvseries, tvepisode, video, etc.).
• primaryTitle (string) – the most popular title/the title used by the filmmakers on promotional materials at the point of release.
• originalTitle (string) – original title, in the original language.
• isAdult (boolean) – 0: non-adult title; 1: adult title.
• startYear (YYYY) – represents the release year of a title. In the case of TV Series, it is the series release year.
• endYear (YYYY) – TV Series end year. ‘\N’ for all other title types.
• runtimeMinutes – primary runtime of the title, in minutes.
• genres (string array) – includes up to three genres associated with the title.

Then, we’ll split the dataset into train and test. We will be using only 13k movies instead of all the data records, and we won’t shuffle the data so we know which movies will be in our test data.

We are also creating a new Movie_id for our test dataset which will help us later on.

We’ll select the most important columns in our dataset, that is, the ones that we will use to make a movie prediction.

We’ll check if there is any missing data in the most important column in our dataset; if that is the case, we will clean the data by removing all null values.

Then, we’ll define a function that will create a new column, combining all the important column values into one string for each record in our dataset.

We’ll create the new column for our dataset.

We will create a new variable named cm that will contain a matrix of token counts for each important_features value.

Then, we’ll create a new variable named cs; this will store a matrix of the similarities between each important_features record for each movie, meaning it will include how similar each pair of movies in our dataset is.

This is a number between 0 and 1, we can see that the diagonal is 1 because each movie is 100% similar to itself.

We can check the size of this matrix, which will be Numbers of Movies * Numbers of Movies.

So, time to start the recommendation part. We will have a movie that the user has seen and we will recommend a similar movie to that one. In our example, the movie that the user has seen will be ‘Art of Falling in Love’, ID ‘12870’ 

*Notice that it has to be an existent movie in the dataset and that, if you change it, you’ll have to change the test*

Now, we will create a list of all the similarity score values for all the movies compared to the movie we’ve chosen. (Meaning get a column or a row in the cs matrix).

Once we get it, we’ll sort it from most to least similar.

And we’ll show the top 10.

Great Work! 

Looks like it’s working for romantic movies, but, to test it properly, we should test another genre. To do this, we’ll create a function we can call.

We actually wrote 3 functions; let’s have a look: 

We are basically doing the same thing, but generalized for any movie so we can test our program, and called print a few times to make it more readable.

Let’s check how it works. 

Ok, the exception looks good! 

Let’s see a real result now.

Great! All of them are Alien/Galaxy related, looks good enough.

I’m not sure all these movies are entirely similar, but this can be due to our dataset, or even our training selection. In any case, our simple recommendation system has passed the test for sure! 

Congratulations! You should be proud of yourself! 

What do you think? Can this be improved by collaborative filtering? Would you take up the challenge? 

Final thoughts on Python Recommendation Systems

The machine learning world can be overwhelming, but as you can see, it’s not rocket science! Anyone can build a basic system that works, and it can certainly save you time and money in your e-commerce business. Imagine recommending 1000 movies on our own! You would need an entire team to sort through the data, but with automation, it falls into the probability and statistics world, and it can be coded.

So we encourage you to delve deeper into this world, and hope this information helps you!

The post Python Recommendation Systems appeared first on asap developers.

At some point, almost all development teams have to choose the best language to use for their software. That is why, in this article, we’ll be comparing Golang vs Python based on different attrasaibutes to help you decide which language is best suited for you and your team. More specifically, these are the attributes we’ll be looking at:

• Performance
• Scalability
• Applications
• Learning curve
• Rapid prototyping

We’ve chosen Golang vs Python as these two programming languages are often compared in the business community because they are not only good for creating web applications but also help automate business-related tasks.

Before we get around to comparing Golang and Python, however, let us start by introducing you to these languages.

Speaking of Golang (Go)

Developed by Google back in 2009, Go was a solution to a problem. Its aim was to create a language that took away all the baggage and excesses found in languages such as C++. This gave it a performance and speed boost that makes working with it a delight. Plus, most developers picking up Go for the first time will not be left adrift since its familiar elements and ease of use lend a helping hand.

This language supports concurrent programming and also allows you to run multiple processes simultaneously.

Let’s see an example….

Imagine you run an e-commerce store that takes orders from customers, checks inventory and charges for orders. In this case, each functionality is relatively small so, if you have a website built with Go, you can expect improved maintainability for relatively small services and an application that is easier to test and deploy effectively.

A Python’s tale

Some developers think that Python’s where it all starts and ends. It has gained a cult-like following because it is an excellent programming language. The internet is filled with wonders that were created using Python.

Python is capable of unleashing its full potential when used in web development, machine learning and fintech. Moreover, thanks to its scalability, it is also popular among startups. 

However, when looking for a tech partner who’ll help you launch your Python project, make sure they are working with Python 3 as the previous version of the language became obsolete in early 2020.

Language simplicity means faster backend development 

To give you a practical example, if you were to code the same functionality using Java, it would take three to five times longer than with Python. The equation is simple here: fewer lines of code mean faster development and easier maintenance.

Golang vs Python: Performance

There are a lot of practical tests for API response time and, on this front, Golang is the absolute winner.  Python is a great language, but its performance isn’t the best for use cases such as serialization/deserialization, ranking and aggregation. There are cases with NoSQL databases such as Cassandra where it will take less time for the engine to retrieve data than for Python to turn it into objects.

Golang vs Python: Scalability

Building a truly scalable application is an art. If a system does not scale, it can be a problem for any business. 

So, Google developers created Golang to help solve problems that are at Google’s scale. This involved thousands of programmers working on a large server software hosted on thousands of clusters. Therefore, Golang has support for concurrent process channeling.

Python has a really hard time with concurrency, but can implement parallelism through threads. 

However, when it’s all said and done, Golang takes this one as well.

Golang vs Python: Applications

There isn’t a clear winner for this category. On one hand, Python is widely used in the field of data analytics, artificial intelligence, deep learning and web development.

This is thanks to the amazing libraries Python offers which make developers’ lives easier. 

Golang, on the other hand, is mostly used for systems programming. Due to its concurrency support, it also has been used in cloud computing or clutter computing. When it comes to good libraries, it also has a few interesting ones.

But, given that Python can be used in more diverse fields, and the number of amazing libraries available for it, let’s give it this point.

Golang vs Python: Learning curve

If you’re new to coding, you may be looking at different aspects of your programming language than someone who wants to write an advanced physics simulator for wormhole experimentation. For example, you may want to learn a small language, one that does not imply learning complex syntax, or a flexible language that lets you express yourself more naturally. 

Go is a small language, it doesn’t have many different ways to do the same thing and there aren’t many features built into the language to cover every possible thing you might want to do. In contrast, Python has more features: classes, lambdas, tuples, iterators and many more. 

But, even though it has many more features, Python still feels natural. Just take a look at the following snippets. This first one is written in Python: 

As you can see, it’s pretty straightforward. Next, let’s take a look at this other function using Go:

func Filter(vs []string, f func(string) bool) []string {
vsf := make([]string, 0)
for _, v := range vs {
if f(v) {
vsf = append(vsf, v)
}
}
return vsf
}

Go may be simple, but that’s not the same as easy. If this language is new to you, it can be hard to figure out what a line of code is meant to do. If you’re taking your first steps in programming, Python will grant you an easier and more pleasant experience.

Golang vs Python: Rapid prototyping

Often in software development, a project’s requirements are not detailed in advance. Instead, a team may just want to get something up and running that proves the concept and gives results in a simple prototype they can show users, to get feedback and iterate over the product. 

Python is excellent for this as it allows developers to get their thoughts down quickly in a form that looks almost like English, and results in a program that will probably run. Python’s dynamic typing is very forgiving as you don’t have to worry about knowing exactly what something is. 

In contrast, Go is strict. It’s statically typed which means the compiler insists on verifying every file you pass to a function before executing it. This can make the programming experience feel a bit like doing paperwork just for a proof of concept. 

Final thoughts

Golang vs Python, both deserve serious consideration. If at all possible, you should aim to have at least some level of experience in both as it will help you in any tech career, or it might even be enjoyable as a hobby.

Both have benefits, depending on what your goal is. There is still a lot more that remains to be seen regarding Go’s applicability and its potential to reach the same levels of Python in terms of industry adoption. As of now, Python continues to be the winner in terms of languages used across different industries and it is likely to continue holding this title in the near future.

The post Golang vs Python appeared first on asap developers.

In today’s world, businesses need to make critical choices when it comes to selecting mobile technologies and they also need to test and assess these technologies daily. Organizations that are unable to produce easy-to-use products and services are at risk of falling behind their competition.

Over the last few years, various mobile frameworks, such as React Native, Xamarin and AngularJS, have been developed. These make it simpler to create digital experiences. More recently, a new player has entered the game: Google Flutter.

Then, when it comes to the backend, there is Python. This language makes the learning process easier and its readability means communication is smoother for programmers working on the same project. This also makes it easier for a different programmer working on later additions to understand and work with the original code.

In this article, we’ll show you how to connect a Python Django backend with a Flutter frontend using GraphQL.

Before we get started, let’s take a look at why we choose to use these tools.

Why we use Flutter

Flutter is a Google UI toolkit for building native apps for Android, iOS, PC and the web from a single codebase in record time. Flutter uses Dart as its programming language, a modern alternative to Javascript developed by Google. This OOP language is optimized for UI, fast on all platforms and similar to JavaScript with elements of Java. Flutter helps you develop faster, includes countless widgets, is open-source and portable, and has a great set of testing and debugging tools to optimize your app.

Why we use GraphQ

According to its website, “GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.”

There are many advantages to using GraphQL. To start with, it creates a uniform API across an entire application without being limited by a specific storage engine. Moreover, GraphQL APIs leverage your existing data and GraphQL engines are available in many languages. Finally, GraphQL calls the functions you provide for each field in the type system with optimal concurrency.

Why we use Python        

There has long been a debate on which is the best backend language. Is it Swift? Or Java? Maybe C++? Well, although our programmers have an extensive toolkit that prepares them to tackle the most challenging problems, we do have a favorite. Python increases productivity, is platform-independent and easy to read, is great for machine learning, and has countless resources and a large community behind it.

Why we use Django     

Django is an open-source Python web framework that has been gaining a lot of popularity lately. It has been used extensively by companies such as Mozilla, Spotify and NASA, as well as within our team. Django is not only fast, secure and versatile: it’s also great for SEO, highly-scalable and portable.

Now, let’s get into our app. Here are the steps you should follow:

1. Start a new Django Project

Create the virtual env & Activate it 

mkvirtualenv graphql-auth

Create the Django Project

pip install django
django-admin startproject auth
cd auth

Create the custom user model

python manage.py startapp users

Then, create the custom user model: 

Link: script

Add it to the settings

Link: script

Finally, migrate

python manage.py makemigrations
python manage.py migrate

2. Setup Graphene and GraphQL JWT

Install Graphene

pip install graphene-django django-graphql-jwt==0.3.0

Add the url

Link: script

Edit your settings

Link: script

Install Django-GraphQL-Auth

pip install django-graphql-auth

Link: script

Run it: 

python manage.py migrate

Setup Email Backend

The default configuration is to send an activation email when registering users; you can set this to False on your settings, but you still need an email backend for resetting passwords.

The quickest solution for development is to set up a console email backend. To do this, simply add the following to your settings.py.

EMAIL_BACKEND ='django.core.mail.backends.console.EmailBackend'

Query: Create the schema

Create a file called schema.py next to your settings.py with the following lines:

Link: script

And add Django-Filter to the installed apps.

pip install django-filter

# auth.settings.py

Link: script

Making your first query

Start the dev server:

python manage.py runserver

Open your browser:

http://127.0.0.1:8000/graphql

On your GRAPHQL_JWT[“JWT_ALLOW_ANY_CLASSES”] setting, add the following:

Link: script

Let’s try to register a new user:

Link: script

Something went wrong! Now you know the response format that you can expect of all mutations

Let’s try again, this time, with a super-secret password:

Link: script

Check if the new user is really on the database:

Link: script

Congratulations! You have successfully built your very first authentication system with GraphQL! Now, let’s create a beautiful frontend for it!

3. Create the Flutter login app

flutter create auth_frontend
cd auth_frontend
flutter run -d chrome

The first time you use it, you’ll see a simple app where you can press a button to increase a counter.
For this tutorial, we have prepared a login example:

So far, we have just made the following changes to our main.dart:

Link: script

As you can see, a method is called when you press “register”, or “login”. Those are the functions we will implement with a simple backend call.

4. SetUp GraphQL in Flutter login

GraphQL has many benefits, both for the client (devices will need fewer requests and, therefore, reduce data usage) and the programmer (requests are arguable, they have the same structure as the request).

Installation

First, add the following packages to your project’s dependencies: pubspec.yaml

dependencies:
graphql_flutter: ^3.0.0

Then, create a graphQL configuration file where you will set up the backend URL, and create the GraphQLClient object.

Link: script

You will need another file to place your GraphQL queries:

Link: script

Then, modify your main.dart file to talk to the backend in Register.

First, import the necessary packages:

Link: script

Then, create the configuration objects in main:

Link: script

In the _LoginpageState class, add the following:

Link: script

Then, make the _createAccountPressed method async and add this code:

Link: script

Now, be sure your backend is running as it should, and try to register with a new account in your frontend server. You may see this beautiful error:

Blocked by CORS policy. This happens because your backend does not accept requests from Flutter. There are many fixes for this, and it will depend on which environment you are deploying. For production, you should whitelist your frontend URL in the Django settings. But, for now, we will fix this in settings.py by allowing all CORS: 

pip install django-cors-headers

Link: script

Finally, try to register a new user again and, if you enter a valid email, you should see a success message in the console!

Congratulations! You have built a complete web app, with both a frontend and backend! Go ahead and build something amazing!

And, here is the entire project for you to download: https://github.com/JoaquinAcuna97/Flutter-Django-Login 

Final thoughts on Flutter login

Adding a widget with Flutter is really simple thanks to the official docs and you can find many widgets to add to your app. These include Appbars, icons, images, inputs, and animations, among many others. This, combined with the possibility to connect any backend services, including the potential of Django, is something that can bring a lot of value to your products, and keep your whole dev team happy!

The post Flutter Login app with Python Backend appeared first on asap developers.

When it comes to developing an app, there are quite a few programming languages and tools to choose from. Developers have long been debating which is the best one, but the truth is, most of the time, it depends on the project you have in mind. In this article, we’ll take a look at Golang advantages (an open-source alternative), and why it might be the right fit for your project. We’ll give you an overview of this technology and go over its most significant features to help you decide whether you should look for Golang development services.

What is Golang?

Golang (or Go) is an open-source, compiled programming language developed in 2009 by Google with the help of many community collaborators. Golang has had many releases since then and is currently on version 1.15.2. In addition to Google, other big companies that use this coding language include Apple and Facebook.

The language came to be as an alternative to Java and C++ for app developers, providing a consistent language with a focus on code readability and clear documentation, among many other features. Golang is known for its simplicity, reliability and efficient code compilation when it comes to developing software.

Golang advantages:

1. Minimalist and easy to learn

Golang’s specification is merely 50 pages long (Java’s, for example, is 750 pages long) and it’s full of examples. The language is quite easy to read and easy to learn from just this specification (and even more so if you are already well-versed in Java or C). Moreover, its clean syntax means the language is also easy to maintain. Some of the features that make Go so simple include a minimal interface, no implicit conversions, and packages with clear code separation.

2. Fast

The fact that Go is a compiled language means the code you write is directly translated into the relevant format for the processor instead of compiling into byte-code first like other languages do. With no middle-man, Golang is not only faster but also more reliable.

3. Transparent

Go’s syntax is meant to be transparent. It has only one standard code format created automatically by the fmt tool. The language makes it easy for you to always know what your code is doing and estimate resources. Languages like Python are as readable as Go, but not quite as transparent.

4. Large community = Extensive tools

As with most popular programming languages, Golang has a large and supportive community. The language has its own GitHub repository, which includes a number of editors and plugins, and there are also many other resources available, including a Slack channel, a blog, a sub-Reddit and a forum. And if that isn’t enough, there are countless Golang programmers out there open to share their knowledge.

5. Large talent pool

The fact Golang has such a large community also means there are countless developers offering Golang development services. As the most in-demand language in the world, you are sure to have your pick of developers if you’re looking to start a project using Go.

6. Always compatible

Golang offers excellent backward compatibility so, if you develop an app with its current version, you should not have problems with new versions in the future. Go’s compatibility means switching versions of the language at any time should be hassle-free.

7. Scalable

Golang’s advantages includes Goroutines—functions that run simultaneously and independently—, which take little memory space and make it scalable when dealing with several concurrent processes. You can actually run millions of Goroutines without crashing your system, making for a leaner software.

8. Built-in testing

Go includes a built-in testing tool, which, just like everything else regarding this language, was created with simplicity and efficiency in mind. It can be used for various types of testing and profiling, and you can even run tests in parallel, among many other features.

Final thoughts on Golang advantages

As you can see, Go has many perks that make pursuing Golang development services very appealing. If you want more information, you can look at Go’s website to find extensive documentation and tutorials.

Asap developers

asap has been developing web and mobile applications for San Francisco Bay Area companies since 2008. With a team of almost 30 hard-working members, we’re big enough to tackle almost any project and, at the same time, agile enough to respond to the changing needs of our clients. We are passionate about technology and are constantly integrating new tools into our portfolio, including Golang development services. We see our clients as strategic partners, so we offer a comprehensive service that is focused on their success.

The post Golang Advantages appeared first on asap developers.